@pinta365/strava 0.0.1

package/esm/src/resources/segments.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Segments resource
+ */
+import type { StravaClient } from "../client.js";
+import type { DetailedSegment, ExplorerResponse } from "../types/api.js";
+/**
+ * Options for exploring segments
+ */
+export interface ExploreSegmentsOptions {
+    /** Bounding box as [south, west, north, east] */
+    bounds: [number, number, number, number];
+    /** Activity type filter */
+    activityType?: "running" | "riding";
+    /** Minimum category */
+    minCat?: number;
+    /** Maximum category */
+    maxCat?: number;
+}
+/**
+ * Resource for interacting with Strava segments
+ */
+export declare class SegmentsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get segment by ID
+     */
+    getById(id: number): Promise<DetailedSegment>;
+    /**
+     * Explore segments
+     */
+    explore(options: ExploreSegmentsOptions): Promise<ExplorerResponse>;
+    /**
+     * Star segment
+     */
+    star(id: number, starred?: boolean): Promise<DetailedSegment>;
+    /**
+     * Unstar segment
+     */
+    unstar(id: number): Promise<DetailedSegment>;
+}
+//# sourceMappingURL=segments.d.ts.map

package/esm/src/resources/segments.js

@@ -0,0 +1,67 @@
+/**
+ * Segments resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+/**
+ * Resource for interacting with Strava segments
+ */
+export class SegmentsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get segment by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/segments/${id}`,
+        });
+    }
+    /**
+     * Explore segments
+     */
+    async explore(options) {
+        const [south, west, north, east] = options.bounds;
+        const query = {
+            bounds: `${south},${west},${north},${east}`,
+        };
+        if (options.activityType) {
+            query.activity_type = options.activityType;
+        }
+        if (options.minCat !== undefined) {
+            query.min_cat = options.minCat;
+        }
+        if (options.maxCat !== undefined) {
+            query.max_cat = options.maxCat;
+        }
+        return await this.client.request({
+            method: "GET",
+            path: "/segments/explore",
+            query,
+        });
+    }
+    /**
+     * Star segment
+     */
+    async star(id, starred = true) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "PUT",
+            path: `/segments/${id}/starred`,
+            query: { starred: starred ? "true" : "false" },
+        });
+    }
+    /**
+     * Unstar segment
+     */
+    async unstar(id) {
+        return await this.star(id, false);
+    }
+}

package/esm/src/resources/streams.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Streams resource
+ */
+import type { StravaClient } from "../client.js";
+import type { StreamSet } from "../types/api.js";
+/**
+ * Available stream types
+ */
+export type StreamType = "time" | "distance" | "latlng" | "altitude" | "velocity_smooth" | "heartrate" | "cadence" | "watts" | "temp" | "moving" | "grade_smooth";
+/**
+ * Options for getting streams
+ */
+export interface GetStreamsOptions {
+    /** Stream types to retrieve */
+    types?: StreamType[];
+    /** Whether to key streams by type */
+    keyByType?: boolean;
+}
+/**
+ * Resource for interacting with Strava streams
+ */
+export declare class StreamsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get activity streams
+     */
+    getForActivity(id: number, options?: GetStreamsOptions): Promise<StreamSet>;
+    /**
+     * Get segment effort streams
+     */
+    getForSegmentEffort(id: number, options?: GetStreamsOptions): Promise<StreamSet>;
+    /**
+     * Get segment streams
+     */
+    getForSegment(id: number, options?: Omit<GetStreamsOptions, "types"> & {
+        types?: Array<"distance" | "latlng" | "altitude">;
+    }): Promise<StreamSet>;
+    /**
+     * Get route streams
+     */
+    getForRoute(id: number): Promise<StreamSet>;
+}
+//# sourceMappingURL=streams.d.ts.map

package/esm/src/resources/streams.js

@@ -0,0 +1,75 @@
+/**
+ * Streams resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+/**
+ * Resource for interacting with Strava streams
+ */
+export class StreamsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get activity streams
+     */
+    async getForActivity(id, options) {
+        validatePositiveInteger(id, "id");
+        const types = options?.types || ["time", "distance", "latlng", "altitude", "heartrate"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get segment effort streams
+     */
+    async getForSegmentEffort(id, options) {
+        validatePositiveInteger(id, "id");
+        const types = options?.types || ["time", "distance", "latlng", "altitude", "heartrate"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/segment_efforts/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get segment streams
+     */
+    async getForSegment(id, options) {
+        validatePositiveInteger(id, "id");
+        const types = options?.types || ["distance", "latlng", "altitude"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/segments/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get route streams
+     */
+    async getForRoute(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/routes/${id}/streams`,
+        });
+    }
+}

package/esm/src/resources/uploads.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Uploads resource
+ */
+import type { StravaClient } from "../client.js";
+import type { Upload } from "../types/api.js";
+/**
+ * Options for creating an upload
+ */
+export interface CreateUploadOptions {
+    /** Activity file (FIT, TCX, or GPX format) */
+    file: File | Blob | Uint8Array;
+    /** Activity name */
+    name?: string;
+    /** Activity description */
+    description?: string;
+    /** Whether activity was done on trainer */
+    trainer?: boolean;
+    /** Whether activity is a commute */
+    commute?: boolean;
+    /** File data type */
+    dataType?: "fit" | "fit.gz" | "tcx" | "tcx.gz" | "gpx" | "gpx.gz";
+    /** External ID for the activity */
+    externalId?: string;
+}
+/**
+ * Resource for uploading activities to Strava
+ */
+export declare class UploadsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Create upload
+     */
+    create(options: CreateUploadOptions): Promise<Upload>;
+    /**
+     * Get upload by ID
+     */
+    getById(id: number): Promise<Upload>;
+    private getAccessToken;
+}
+//# sourceMappingURL=uploads.d.ts.map

package/esm/src/resources/uploads.js

@@ -0,0 +1,79 @@
+/**
+ * Uploads resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+/**
+ * Resource for uploading activities to Strava
+ */
+export class UploadsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Create upload
+     */
+    async create(options) {
+        const formData = new FormData();
+        if (options.file instanceof File) {
+            formData.append("file", options.file);
+        }
+        else if (options.file instanceof Blob) {
+            formData.append("file", options.file, "activity.fit");
+        }
+        else {
+            // Uint8Array
+            const blob = new Blob([options.file], { type: "application/octet-stream" });
+            formData.append("file", blob, "activity.fit");
+        }
+        if (options.name) {
+            formData.append("name", options.name);
+        }
+        if (options.description) {
+            formData.append("description", options.description);
+        }
+        if (options.trainer !== undefined) {
+            formData.append("trainer", options.trainer ? "1" : "0");
+        }
+        if (options.commute !== undefined) {
+            formData.append("commute", options.commute ? "1" : "0");
+        }
+        if (options.dataType) {
+            formData.append("data_type", options.dataType);
+        }
+        if (options.externalId) {
+            formData.append("external_id", options.externalId);
+        }
+        // Use direct fetch for multipart/form-data
+        const token = await this.getAccessToken();
+        const response = await fetch("https://www.strava.com/api/v3/uploads", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${token}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(`Upload failed: ${error.message || response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get upload by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/uploads/${id}`,
+        });
+    }
+    async getAccessToken() {
+        return await this.client.getAccessToken();
+    }
+}

package/esm/src/types/api.d.ts

@@ -0,0 +1,9 @@
+/**
+ * API types - Re-exports and type aliases for generated types
+ *
+ * This file provides convenient access to all generated types from the Swagger specification.
+ * Types are automatically generated from https://developers.strava.com/swagger/swagger.json
+ */
+export * from "./generated.js";
+export type { ActivityStats, ActivityTotal, ActivityType, ActivityZone, ClubActivity, ClubAnnouncement, ClubAthlete, Comment, DetailedActivity, DetailedActivity as Activity, DetailedAthlete as Athlete, DetailedClub as Club, DetailedGear as Gear, DetailedSegment as Segment, DetailedSegmentEffort as SegmentEffort, ExplorerResponse, ExplorerSegment, Fault, HeartRateZoneRanges, Lap, LatLng, MetaActivity, MetaAthlete, MetaClub, PhotosSummary, PolylineMap, PowerZoneRanges, Route, Split, SportType, StreamSet, StreamType, SummaryActivity, SummaryAthlete, SummaryClub, SummaryGear, SummaryPRSegmentEffort, SummarySegment, SummarySegmentEffort, UpdatableActivity, Upload, Waypoint, ZoneRange, ZoneRanges, Zones, } from "./generated.js";
+//# sourceMappingURL=api.d.ts.map

package/esm/src/types/api.js

@@ -0,0 +1,7 @@
+/**
+ * API types - Re-exports and type aliases for generated types
+ *
+ * This file provides convenient access to all generated types from the Swagger specification.
+ * Types are automatically generated from https://developers.strava.com/swagger/swagger.json
+ */
+export * from "./generated.js";

package/esm/src/types/common.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Common types and interfaces for the Strava client
+ */
+/**
+ * Retry configuration for failed requests
+ */
+export interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelay?: number;
+    /** Maximum delay in milliseconds (default: 10000) */
+    maxDelay?: number;
+    /** Exponential backoff factor (default: 2) */
+    backoffFactor?: number;
+    /** HTTP status codes that should trigger retry (default: [429, 500, 502, 503, 504]) */
+    retryableStatusCodes?: number[];
+}
+/**
+ * Rate limit strategy for handling rate limit errors
+ * - "queue": Queue requests and process when rate limit resets
+ * - "throw": Immediately throw error when rate limit is hit
+ * - "wait": Wait until rate limit resets before making request
+ */
+export type RateLimitStrategy = "queue" | "throw" | "wait";
+/**
+ * HTTP request configuration
+ */
+export interface RequestConfig {
+    /** HTTP method */
+    method: string;
+    /** API path (without base URL) */
+    path: string;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean | undefined>;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body */
+    body?: unknown;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Pagination options for list endpoints
+ */
+export interface PaginationOptions {
+    /** Page number (default: 1) */
+    page?: number;
+    /** Number of items per page (default: 30, max: 200) */
+    perPage?: number;
+}
+/**
+ * Rate limit information from response headers
+ */
+export interface RateLimitInfo {
+    /** Short-term rate limit (15-minute window) */
+    shortTermLimit?: number;
+    /** Short-term usage count */
+    shortTermUsage?: number;
+    /** Daily rate limit */
+    dailyLimit?: number;
+    /** Daily usage count */
+    dailyUsage?: number;
+}
+//# sourceMappingURL=common.d.ts.map

package/esm/src/types/common.js

@@ -0,0 +1,4 @@
+/**
+ * Common types and interfaces for the Strava client
+ */
+export {};