@pinta365/strava 0.0.1

package/script/deps/jsr.io/@cross/runtime/1.2.1/mod.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Enum of supported Runtimes.
+ * @enum {string}
+ */
+export declare enum Runtime {
+    Deno = "deno",
+    Bun = "bun",
+    Node = "node",
+    Browser = "browser",
+    Tauri = "tauri",
+    Workerd = "workerd",
+    Netlify = "netlify",
+    EdgeLight = "edgelight",
+    Fastly = "fastly",
+    Unsupported = "unsupported"
+}
+/**
+ * Enum of supported Operating Systems.
+ * @enum {string}
+ */
+export declare enum OperatingSystem {
+    Windows = "windows",
+    macOS = "macos",
+    Linux = "linux",
+    Android = "android",
+    Unix = "unix",
+    iOS = "ios",
+    Unsupported = "unsupported"
+}
+/**
+ * Enum of supported Products.
+ * @enum {string}
+ */
+export declare enum Product {
+    Deno = "deno",
+    Bun = "bun",
+    Node = "node",
+    Tauri = "tauri",
+    Workerd = "workerd",
+    Netlify = "netlify",
+    EdgeLight = "edgelight",
+    Fastly = "fastly",
+    Firefox = "firefox",
+    Safari = "safari",
+    Chrome = "chrome",
+    Edge = "edge",
+    Opera = "opera",
+    Brave = "brave",
+    Unsupported = "unsupported"
+}
+/**
+ * Enum of common CPU architectures.
+ * @enum {string}
+ */
+export declare enum Architecture {
+    x86 = "x86",
+    x64 = "x86_64",
+    arm = "arm",
+    arm64 = "arm64",
+    Unsupported = "unsupported"
+}
+/**
+ * Dynamically determines the current runtime environment.
+ */
+export declare function getCurrentRuntime(): Runtime;
+/**
+ * Dynamically determines the current operating system.
+ */
+export declare function getCurrentOS(): OperatingSystem;
+/**
+ * Determine operating system from user agent string, if possible
+ */
+export declare function getOSFromUserAgent(userAgent: string): OperatingSystem;
+/**
+ * Dynamically determines the current browser and its version (if applicable).
+ */
+export declare function getCurrentProduct(): Product;
+/**
+ * Determines the product from a user agent string, if possible
+ */
+export declare function getProductFromUserAgent(userAgent: string): Product;
+/**
+ * Dynamically determines the version of the current product/runtime
+ * @returns {string} A string containing the detected version, or undefined if the product is not supported.
+ */
+export declare function getCurrentVersion(): string | undefined;
+/**
+ * Determines the product version from a user agent string, if possible
+ */
+export declare function getVersionFromUserAgent(userAgent: string): string | undefined;
+/**
+ * Attempts to determine the current CPU architecture of the runtime's environment.
+ */
+export declare function getCurrentArchitecture(): Architecture;
+/**
+ * Logs current system information to the console.
+ *
+ * @param {boolean} [useTable=false] - If true, formats the output as a table.
+ */
+export declare function dumpSystemInfo(useTable?: boolean): void;
+/**
+ * Gets the current system information as a formatted JSON string.
+ * @returns {string}
+ */
+export declare function getSystemInfo(): string;
+/**
+ * Static variable containing the current runtime.
+ */
+export declare const CurrentRuntime: Runtime;
+/**
+ * Static variable containing the current product.
+ */
+export declare const CurrentProduct: Product;
+/**
+ * Static variable containing the current product/runtime version.
+ */
+export declare const CurrentVersion: string | undefined;
+/**
+ * Static variable containing the current operating system.
+ */
+export declare const CurrentOS: OperatingSystem | undefined;
+/**
+ * Static variable containing the current operating system.
+ */
+export declare const CurrentArchitecture: Architecture | undefined;
+//# sourceMappingURL=mod.d.ts.map

package/script/deps/jsr.io/@cross/runtime/1.2.1/mod.js

@@ -0,0 +1,526 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrentArchitecture = exports.CurrentOS = exports.CurrentVersion = exports.CurrentProduct = exports.CurrentRuntime = exports.Architecture = exports.Product = exports.OperatingSystem = exports.Runtime = void 0;
+exports.getCurrentRuntime = getCurrentRuntime;
+exports.getCurrentOS = getCurrentOS;
+exports.getOSFromUserAgent = getOSFromUserAgent;
+exports.getCurrentProduct = getCurrentProduct;
+exports.getProductFromUserAgent = getProductFromUserAgent;
+exports.getCurrentVersion = getCurrentVersion;
+exports.getVersionFromUserAgent = getVersionFromUserAgent;
+exports.getCurrentArchitecture = getCurrentArchitecture;
+exports.dumpSystemInfo = dumpSystemInfo;
+exports.getSystemInfo = getSystemInfo;
+// deno-lint-ignore-file no-process-global
+/* Private functions */
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+function getChromeVersion(userAgent) {
+    const match = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+function getFirefoxVersion(userAgent) {
+    const match = userAgent.match(/Firefox\/([0-9]+)\./);
+    return match ? match[1] : "Unknown";
+}
+function getEdgeVersion(userAgent) {
+    const match = userAgent.match(/Edg\/([0-9]+)\./);
+    return match ? match[1] : "Unknown";
+}
+function getSafariVersion(userAgent) {
+    const match = userAgent.match(/Version\/([0-9]+)\.([0-9]+)(\.[0-9]+)?/);
+    if (match)
+        return `${match[1]}.${match[2]}`;
+    return "Unknown";
+}
+function getOperaVersion(userAgent) {
+    // Look for either 'Opera/' or 'OPR/' followed by the version
+    const match = userAgent.match(/(Opera|OPR)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+function getBraveVersion(userAgent) {
+    const match = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+/**
+ * Enum of supported Runtimes.
+ * @enum {string}
+ */
+var Runtime;
+(function (Runtime) {
+    Runtime["Deno"] = "deno";
+    Runtime["Bun"] = "bun";
+    Runtime["Node"] = "node";
+    Runtime["Browser"] = "browser";
+    Runtime["Tauri"] = "tauri";
+    Runtime["Workerd"] = "workerd";
+    Runtime["Netlify"] = "netlify";
+    Runtime["EdgeLight"] = "edgelight";
+    Runtime["Fastly"] = "fastly";
+    Runtime["Unsupported"] = "unsupported";
+})(Runtime || (exports.Runtime = Runtime = {}));
+/**
+ * Enum of supported Operating Systems.
+ * @enum {string}
+ */
+var OperatingSystem;
+(function (OperatingSystem) {
+    OperatingSystem["Windows"] = "windows";
+    OperatingSystem["macOS"] = "macos";
+    OperatingSystem["Linux"] = "linux";
+    OperatingSystem["Android"] = "android";
+    OperatingSystem["Unix"] = "unix";
+    OperatingSystem["iOS"] = "ios";
+    OperatingSystem["Unsupported"] = "unsupported";
+})(OperatingSystem || (exports.OperatingSystem = OperatingSystem = {}));
+/**
+ * Enum of supported Products.
+ * @enum {string}
+ */
+var Product;
+(function (Product) {
+    // All runtimes
+    Product["Deno"] = "deno";
+    Product["Bun"] = "bun";
+    Product["Node"] = "node";
+    Product["Tauri"] = "tauri";
+    Product["Workerd"] = "workerd";
+    Product["Netlify"] = "netlify";
+    Product["EdgeLight"] = "edgelight";
+    Product["Fastly"] = "fastly";
+    // All browsers
+    Product["Firefox"] = "firefox";
+    Product["Safari"] = "safari";
+    Product["Chrome"] = "chrome";
+    Product["Edge"] = "edge";
+    Product["Opera"] = "opera";
+    Product["Brave"] = "brave";
+    // And unsupported
+    Product["Unsupported"] = "unsupported";
+})(Product || (exports.Product = Product = {}));
+/**
+ * Enum of common CPU architectures.
+ * @enum {string}
+ */
+var Architecture;
+(function (Architecture) {
+    Architecture["x86"] = "x86";
+    Architecture["x64"] = "x86_64";
+    Architecture["arm"] = "arm";
+    Architecture["arm64"] = "arm64";
+    Architecture["Unsupported"] = "unsupported";
+})(Architecture || (exports.Architecture = Architecture = {}));
+///**
+// * Interface for Tauri-specific information.
+// */
+//export interface TauriInfo {
+//  /** The application version, as defined in `tauri.conf.json`. */
+//  version?: string;
+//  /** The application name, as defined in `tauri.conf.json`. */
+//  name?: string;
+//  /** The application's bundle identifier, as defined in `tauri.conf.json`. */
+//  identifier?: string;
+//  /** The version of the underlying Tauri runtime. */
+//  tauriVersion?: string;
+//}
+/**
+ * Verifies if a property exists in the global namespace and optionally checks its type.
+ *
+ * @param {string} name - The name of the property to verify.
+ * @param {string} [typeString] - The expected type of the property (optional).
+ * @returns {boolean} True if the property exists and matches the type (if provided), False otherwise.
+ */
+function verifyGlobal(name, typeString) {
+    return name in dntShim.dntGlobalThis && (!typeString || typeof dntShim.dntGlobalThis[name] === typeString);
+}
+// Disable getTauriInfo() while I figure some things out.
+///**
+// * Gets Tauri-specific information asynchronously.
+// * Only works when running in a Tauri application.
+// * @returns {Promise<TauriInfo>} Tauri-specific data
+// */
+//export async function getTauriInfo(): Promise<TauriInfo> {
+//  if (getCurrentRuntime() !== Runtime.Tauri) {
+//    return {};
+//  }
+//
+//  try {
+//    const { getVersion, getName, getIdentifier, getTauriVersion } = await import("@tauri-apps/api/app");
+//
+//    const [version, name, identifier, tauriVersion] = await Promise.all([
+//      getVersion().catch(() => undefined),
+//      getName().catch(() => undefined),
+//      getIdentifier().catch(() => undefined),
+//      getTauriVersion().catch(() => undefined),
+//    ]);
+//
+//    return { version, name, identifier, tauriVersion };
+//  } catch (_e) {
+//    return {};
+//  }
+//}
+/**
+ * Dynamically determines the current runtime environment.
+ */
+function getCurrentRuntime() {
+    if (verifyGlobal("Deno", "object"))
+        return Runtime.Deno;
+    if (verifyGlobal("Bun", "object"))
+        return Runtime.Bun;
+    if (verifyGlobal("Netlify", "object"))
+        return Runtime.Netlify;
+    if (verifyGlobal("EdgeRuntime", "string"))
+        return Runtime.EdgeLight;
+    if (globalThis.navigator?.userAgent === "Cloudflare-Workers")
+        return Runtime.Workerd;
+    if (verifyGlobal("fastly", "object"))
+        return Runtime.Fastly;
+    if (verifyGlobal("process", "object") &&
+        //@ts-ignore Runtime detection
+        typeof process.versions !== "undefined" &&
+        //@ts-ignore Runtime detection
+        typeof process.versions.node !== "undefined") {
+        return Runtime.Node;
+    }
+    if (verifyGlobal("window", "object")) { // Check for Browser or Tauri
+        // Check for Tauri first (Tauri runs in a webview, so it has window)
+        if (verifyGlobal("__TAURI__", "object"))
+            return Runtime.Tauri;
+        return Runtime.Browser;
+    }
+    return Runtime.Unsupported;
+}
+/**
+ * Dynamically determines the current operating system.
+ */
+function getCurrentOS() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            switch (Deno.build.os) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "windows":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "illumos":
+                case "netbsd":
+                case "solaris":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Node:
+            // @ts-ignore Cross Runtime
+            switch (process.platform) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "win32":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "openbsd":
+                case "sunos":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Bun:
+            // @ts-ignore Cross Runtime
+            switch (process.platform) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "win32":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "openbsd":
+                case "sunos":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Tauri:
+        case Runtime.Browser: {
+            if ("userAgent" in navigator) {
+                const userAgent = navigator.userAgent;
+                return getOSFromUserAgent(userAgent);
+            }
+        }
+    }
+    return OperatingSystem.Unsupported;
+}
+/**
+ * Determine operating system from user agent string, if possible
+ */
+function getOSFromUserAgent(userAgent) {
+    if (userAgent.indexOf("Win") !== -1)
+        return OperatingSystem.Windows;
+    if (userAgent.indexOf("like Mac") !== -1)
+        return OperatingSystem.iOS;
+    if (userAgent.indexOf("Mac") !== -1)
+        return OperatingSystem.macOS;
+    if (userAgent.indexOf("Android") !== -1)
+        return OperatingSystem.Android;
+    if (userAgent.indexOf("X11") !== -1 || userAgent.indexOf("Linux") !== -1)
+        return OperatingSystem.Linux;
+    return OperatingSystem.Unsupported;
+}
+/**
+ * Dynamically determines the current browser and its version (if applicable).
+ */
+function getCurrentProduct() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            return Product.Deno;
+        case Runtime.Node:
+            return Product.Node;
+        case Runtime.Bun:
+            return Product.Bun;
+        case Runtime.Tauri:
+            return Product.Tauri;
+        case Runtime.Workerd:
+            return Product.Workerd;
+        case Runtime.Netlify:
+            return Product.Netlify;
+        case Runtime.EdgeLight:
+            return Product.EdgeLight;
+        case Runtime.Fastly:
+            return Product.Fastly;
+        case Runtime.Browser: {
+            // Brave can not be detected from user agent string, handle separately
+            if (verifyGlobal("brave") && "brave" in navigator)
+                return Product.Brave;
+            // For browser, get the specific browser
+            const userAgent = navigator.userAgent;
+            return getProductFromUserAgent(userAgent);
+        }
+        default:
+            return Product.Unsupported;
+    }
+}
+/**
+ * Determines the product from a user agent string, if possible
+ */
+function getProductFromUserAgent(userAgent) {
+    if (userAgent.indexOf("Opera") !== -1 || userAgent.indexOf("OPR") !== -1)
+        return Product.Opera;
+    if (userAgent.indexOf("Safari") !== -1 && userAgent.indexOf("Chrome") === -1)
+        return Product.Safari;
+    if (userAgent.indexOf("Edg") !== -1)
+        return Product.Edge;
+    if (userAgent.indexOf("Chrome") !== -1)
+        return Product.Chrome;
+    if (userAgent.indexOf("Firefox") !== -1)
+        return Product.Firefox;
+    return Product.Unsupported;
+}
+/**
+ * Dynamically determines the version of the current product/runtime
+ * @returns {string} A string containing the detected version, or undefined if the product is not supported.
+ */
+function getCurrentVersion() {
+    const product = getCurrentProduct();
+    switch (product) {
+        case Product.Deno:
+            // @ts-ignore Runtime detection
+            return Deno.version.deno;
+        case Product.Node:
+            // @ts-ignore Runtime detection
+            return process.versions.node;
+        case Product.Bun:
+            // @ts-ignore Runtime detection
+            return process.versions.bun;
+        case Product.Tauri: //Fallthrough to default handling.
+        default: {
+            const userAgent = globalThis.navigator?.userAgent;
+            return getVersionFromUserAgent(userAgent);
+        }
+    }
+}
+/**
+ * Determines the product version from a user agent string, if possible
+ */
+function getVersionFromUserAgent(userAgent) {
+    const product = getProductFromUserAgent(userAgent);
+    switch (product) {
+        case Product.Chrome:
+            return getChromeVersion(userAgent);
+        case Product.Firefox:
+            return getFirefoxVersion(userAgent);
+        case Product.Edge:
+            return getEdgeVersion(userAgent);
+        case Product.Safari:
+            return getSafariVersion(userAgent);
+        case Product.Opera:
+            return getOperaVersion(userAgent);
+        case Product.Brave:
+            return getBraveVersion(userAgent);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Attempts to determine the current CPU architecture of the runtime's environment.
+ */
+function getCurrentArchitecture() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            if (Deno.build.arch === "x86_64")
+                return Architecture.x64;
+            if (Deno.build.arch === "aarch64")
+                return Architecture.arm64;
+            if (Deno.build.os === "darwin")
+                return Architecture.x64;
+            return Architecture.x86;
+        case Runtime.Bun:
+        case Runtime.Node:
+            // @ts-ignore Cross Runtime
+            switch (process.arch) {
+                case "arm":
+                    return Architecture.arm;
+                case "arm64":
+                    return Architecture.arm64;
+                case "ia32":
+                    return Architecture.x86;
+                case "x64":
+                    return Architecture.x64;
+                case "loong64":
+                case "mips":
+                case "mipsel":
+                case "ppc":
+                case "ppc64":
+                case "riscv64":
+                case "s390":
+                case "s390x":
+                    return Architecture.Unsupported;
+            }
+            return Architecture.Unsupported;
+        case Runtime.Tauri:
+        case Runtime.Browser: {
+            const userAgent = navigator.userAgent;
+            // @ts-ignore Cross Runtime
+            const platform = navigator.platform;
+            if (platform.indexOf("Win64") !== -1 || platform.indexOf("x64") !== -1 || platform.indexOf("x86_64") !== -1)
+                return Architecture.x64;
+            if (platform.indexOf("Win32") !== -1 || (platform.indexOf("x86") !== -1 && platform.indexOf("x86_64") === -1))
+                return Architecture.x86;
+            if (userAgent.indexOf("Win64") !== -1 || userAgent.indexOf("x64") !== -1 || userAgent.indexOf("x86_64") !== -1)
+                return Architecture.x64;
+            if (userAgent.indexOf("Win32") !== -1 || (userAgent.indexOf("x86") !== -1 && userAgent.indexOf("x86_64") === -1))
+                return Architecture.x86;
+            if (userAgent.indexOf("arm64") !== -1)
+                return Architecture.arm64;
+            if (userAgent.indexOf("arm") !== -1) {
+                return Architecture.arm;
+            }
+            // @ts-ignore Cross Runtime
+            if (platform.indexOf("iPhone") || platform.indexOf("iPad") || (userAgent.indexOf("Mac") !== -1 && "ontouchend" in document)) {
+                // Likely aarch64 on newer iOS devices and Apple Silicon Macs
+                return Architecture.arm64;
+            }
+            return Architecture.Unsupported;
+        }
+    }
+    return Architecture.Unsupported;
+}
+/**
+ * Retrieves the current system information.
+ * @returns {SystemInfo} An object containing the system information.
+ */
+function getSystemInfoInternal() {
+    const systemInfo = {
+        runtime: exports.CurrentRuntime,
+        product: exports.CurrentProduct,
+        version: exports.CurrentVersion,
+        os: exports.CurrentOS,
+        architecture: exports.CurrentArchitecture,
+    };
+    return systemInfo;
+}
+/**
+ * Logs current system information to the console.
+ *
+ * @param {boolean} [useTable=false] - If true, formats the output as a table.
+ */
+function dumpSystemInfo(useTable = false) {
+    const systemInfo = getSystemInfoInternal();
+    if (useTable) {
+        console.table(systemInfo);
+    }
+    else {
+        console.log(JSON.stringify(systemInfo, null, 2));
+    }
+}
+/**
+ * Gets the current system information as a formatted JSON string.
+ * @returns {string}
+ */
+function getSystemInfo() {
+    const systemInfo = getSystemInfoInternal();
+    return JSON.stringify(systemInfo);
+}
+/**
+ * Static variable containing the current runtime.
+ */
+exports.CurrentRuntime = getCurrentRuntime();
+/**
+ * Static variable containing the current product.
+ */
+exports.CurrentProduct = getCurrentProduct();
+/**
+ * Static variable containing the current product/runtime version.
+ */
+exports.CurrentVersion = getCurrentVersion();
+/**
+ * Static variable containing the current operating system.
+ */
+exports.CurrentOS = getCurrentOS();
+/**
+ * Static variable containing the current operating system.
+ */
+exports.CurrentArchitecture = getCurrentArchitecture();

package/script/mod.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @pinta365/strava - TypeScript client for Strava API v3
+ *
+ * A cross-runtime (Deno, Node.js, Bun, Browser) library for interacting with the Strava API.
+ */
+export { StravaClient } from "./src/client.js";
+export type { AuthCredentials, ClientOptions } from "./src/client.js";
+export { StravaAuthError, StravaError, StravaNotFoundError, StravaRateLimitError, StravaServerError, StravaValidationError } from "./src/errors.js";
+export { exchangeCode, getAuthorizationUrl, OAuthManager, refreshAccessToken } from "./src/auth/oauth.js";
+export { formatScopes, hasAllScopes, hasScope, parseScopes, StravaScope, validateScopes } from "./src/auth/scopes.js";
+export type { TokenData, TokenStore } from "./src/auth/token-store.js";
+export { FileSystemTokenStore, getDefaultTokenStore, LocalStorageTokenStore, MemoryTokenStore } from "./src/auth/token-store.js";
+export type { PaginationOptions, RateLimitInfo, RateLimitStrategy, RequestConfig, RetryConfig } from "./src/types/common.js";
+export type { Activity, ActivityStats, ActivityTotal, ActivityType, ActivityZone, Athlete, Club, Comment, DetailedActivity, DetailedAthlete, DetailedClub, DetailedGear, DetailedSegment, DetailedSegmentEffort, ExplorerResponse, ExplorerSegment, Gear, Lap, LatLng, PhotosSummary, PolylineMap, Route, Segment, SegmentEffort, Split, SportType, StreamSet, SummaryActivity, SummaryAthlete, SummaryClub, SummaryGear, SummaryPRSegmentEffort, SummarySegment, SummarySegmentEffort, UpdatableActivity, Upload, Waypoint, Zones, } from "./src/types/api.js";
+export { AthletesResource } from "./src/resources/athletes.js";
+export { ActivitiesResource } from "./src/resources/activities.js";
+export { SegmentsResource } from "./src/resources/segments.js";
+export { SegmentEffortsResource } from "./src/resources/segment-efforts.js";
+export { ClubsResource } from "./src/resources/clubs.js";
+export { GearsResource } from "./src/resources/gears.js";
+export { RoutesResource } from "./src/resources/routes.js";
+export { UploadsResource } from "./src/resources/uploads.js";
+export { StreamsResource } from "./src/resources/streams.js";
+export { buildPaginationQuery, listAll, PaginatedIterator } from "./src/utils/pagination.js";
+export { addComputedFields, applyTransformations, flattenResponses, transformDates } from "./src/utils/transformers.js";
+export { validateDate, validateNonEmptyString, validateNonNegativeInteger, validatePagination, validatePositiveInteger, validateRange, } from "./src/utils/validators.js";
+//# sourceMappingURL=mod.d.ts.map