trainingpeaks-sdk/dist/types/index.d.ts

TypeScript SDK for TrainingPeaks API integration

export declare enum ElementType {
    STEP = "step",
    REPETITION = "repetition"
}
export declare enum LengthUnit {
    SECOND = "second",
    MINUTE = "minute",
    HOUR = "hour",
    REPETITION = "repetition",
    METER = "meter",
    KILOMETER = "kilometer",
    MILE = "mile"
}
export declare enum LengthMetric {
    DURATION = "duration",
    DISTANCE = "distance"
}
export declare enum IntensityMetric {
    PERCENT_OF_THRESHOLD_PACE = "percentOfThresholdPace",
    PERCENT_OF_THRESHOLD_POWER = "percentOfThresholdPower",
    HEART_RATE = "heartRate",
    POWER = "power",
    PACE = "pace",
    SPEED = "speed"
}
export declare enum IntensityTargetType {
    TARGET = "target",
    RANGE = "range"
}
export declare enum IntensityClass {
    ACTIVE = "active",
    REST = "rest",
    WARM_UP = "warmUp",
    COOL_DOWN = "coolDown"
}
export declare enum Difficulty {
    EASY = "easy",
    MODERATE = "moderate",
    HARD = "hard",
    EXTREME = "extreme"
}
export declare enum ActivityType {
    RUN = "run",
    BIKE = "bike",
    SWIM = "swim",
    STRENGTH = "strength",
    OTHER = "other"
}
export declare enum AuthMethod {
    WEB = "web",
    API = "api"
}
export declare enum ErrorType {
    VALIDATION_ERROR = "VALIDATION_ERROR",
    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
    AUTHORIZATION_ERROR = "AUTHORIZATION_ERROR",
    NETWORK_ERROR = "NETWORK_ERROR",
    UPLOAD_ERROR = "UPLOAD_ERROR",
    RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
    ERROR = "ERROR"
}
export declare enum OperationType {
    LOGIN = "login",
    LOGOUT = "logout",
    GET_CURRENT_USER = "getCurrentUser",
    GET_CURRENT_TOKEN = "getCurrentToken",
    GET_USER_ID = "getUserId"
}
export declare enum WorkoutTypeInternal {
    STRUCTURED = "structured",
    FILE = "file",
    MANUAL = "manual",
    FILE_BASED = "file-based",
    SIMPLE = "simple"
}
export declare enum SortOption {
    DATE = "date",
    NAME = "name",
    DURATION = "duration",
    DISTANCE = "distance"
}
export declare enum LoginMethod {
    WEB = "web",
    CREDENTIALS = "credentials"
}
export declare enum SimpleWorkoutElementType {
    WARMUP = "warmup",
    INTERVAL = "interval",
    RECOVERY = "recovery",
    COOLDOWN = "cooldown",
    STEADY = "steady"
}
export type TrainingPeaksConfig = {
    baseUrl?: string;
    timeout?: number;
    headers?: Record<string, string>;
    debug?: boolean;
    authMethod?: AuthMethod;
    webAuth?: {
        headless?: boolean;
        timeout?: number;
        executablePath?: string;
    };
};
export type LoginCredentials = {
    username: string;
    password: string;
};
export type WorkoutData = {
    name: string;
    description?: string;
    date?: string;
    duration?: number;
    distance?: number;
    type?: WorkoutType;
    fileData?: WorkoutFileData;
};
export type WorkoutFileData = {
    filename: string;
    content: Uint8Array | string | Buffer;
    mimeType: string;
};
export declare enum WorkoutType {
    BIKE = "BIKE",
    RUN = "RUN",
    SWIM = "SWIM",
    OTHER = "OTHER"
}
export type UploadResponse = {
    id: string;
    status: string;
    message?: string;
    workoutId?: string;
    errors?: string[];
};
export type WorkoutStructureStep = {
    name: string;
    length: WorkoutLength;
    targets: WorkoutTarget[];
    intensityClass: IntensityClass;
    openDuration: boolean;
};
export type WorkoutLength = {
    value: number;
    unit: LengthUnit;
};
export type WorkoutTarget = {
    minValue: number;
    maxValue: number;
};
export type WorkoutStructureElement = {
    type: ElementType;
    length: WorkoutLength;
    steps: WorkoutStructureStep[];
    begin: number;
    end: number;
};
export type WorkoutStructure = {
    structure: WorkoutStructureElement[];
    polyline: number[][];
    primaryLengthMetric: LengthMetric;
    primaryIntensityMetric: IntensityMetric;
    primaryIntensityTargetOrRange: IntensityTargetType;
};
export type StructuredWorkoutRequest = {
    athleteId: number;
    title: string;
    workoutTypeValueId: number;
    code?: string | null;
    workoutDay: string;
    startTime?: string | null;
    startTimePlanned?: string | null;
    isItAnOr: boolean;
    isHidden?: boolean | null;
    completed?: boolean | null;
    description?: string | null;
    userTags?: string;
    coachComments?: string | null;
    workoutComments?: string[];
    newComment?: string | null;
    hasPrivateWorkoutCommentForCaller?: boolean;
    hasPrivateWorkoutNoteForCaller?: boolean;
    publicSettingValue?: number;
    distance?: number | null;
    distancePlanned?: number | null;
    distanceCustomized?: number | null;
    distanceUnitsCustomized?: string | null;
    totalTime?: number | null;
    totalTimePlanned?: number | null;
    heartRateMinimum?: number | null;
    heartRateMaximum?: number | null;
    heartRateAverage?: number | null;
    calories?: number | null;
    caloriesPlanned?: number | null;
    tssActual?: number | null;
    tssPlanned?: number | null;
    tssSource?: number;
    if?: number | null;
    ifPlanned?: number | null;
    velocityAverage?: number | null;
    velocityPlanned?: number | null;
    velocityMaximum?: number | null;
    normalizedSpeedActual?: number | null;
    normalizedPowerActual?: number | null;
    powerAverage?: number | null;
    powerMaximum?: number | null;
    energy?: number | null;
    energyPlanned?: number | null;
    elevationGain?: number | null;
    elevationGainPlanned?: number | null;
    elevationLoss?: number | null;
    elevationMinimum?: number | null;
    elevationAverage?: number | null;
    elevationMaximum?: number | null;
    torqueAverage?: number | null;
    torqueMaximum?: number | null;
    tempMin?: number | null;
    tempAvg?: number | null;
    tempMax?: number | null;
    cadenceAverage?: number | null;
    cadenceMaximum?: number | null;
    lastModifiedDate?: string;
    equipmentBikeId?: number | null;
    equipmentShoeId?: number | null;
    isLocked?: boolean | null;
    complianceDurationPercent?: number | null;
    complianceDistancePercent?: number | null;
    complianceTssPercent?: number | null;
    rpe?: number | null;
    feeling?: number | null;
    structure: WorkoutStructure;
    orderOnDay?: number | null;
    personalRecordCount?: number;
    syncedTo?: string | null;
    poolLengthOptionId?: number | null;
    workoutSubTypeId?: number | null;
};
export type StructuredWorkoutResponse = StructuredWorkoutRequest & {
    workoutId: number;
    sharedWorkoutInformationKey?: string;
    sharedWorkoutInformationExpireKey?: string;
};
export type CreateStructuredWorkoutRequest = {
    athleteId: number;
    title: string;
    workoutTypeValueId: number;
    workoutDay: string;
    structure: WorkoutStructureValueObject;
    metadata?: {
        code?: string;
        description?: string;
        userTags?: string;
        coachComments?: string;
        publicSettingValue?: number;
        athleteWeight?: number;
        activityType?: WorkoutType;
        plannedMetrics?: {
            totalTimePlanned?: number;
            tssPlanned?: number;
            ifPlanned?: number;
            velocityPlanned?: number;
            caloriesPlanned?: number;
            distancePlanned?: number;
            elevationGainPlanned?: number;
            energyPlanned?: number;
        };
        equipment?: {
            bikeId?: number;
            shoeId?: number;
        };
    };
};
export type CreateStructuredWorkoutResponse = {
    success: boolean;
    workoutId?: number;
    message: string;
    errors?: string[];
    workout?: StructuredWorkoutResponse;
};
export type ApiResponse<T = unknown> = {
    data: T;
    status: number;
    message?: string;
};
export type RequestOptions = {
    headers?: Record<string, string>;
    timeout?: number;
    retry?: RetryConfig;
};
export type RetryConfig = {
    attempts: number;
    delay: number;
    backoff: number;
};
export type SimpleWorkoutStructureElement = {
    type: ElementType;
    length: WorkoutLength;
    steps: WorkoutStructureStep[];
};
export type SimpleWorkoutStructure = {
    structure: SimpleWorkoutStructureElement[];
    primaryLengthMetric: LengthMetric;
    primaryIntensityMetric: IntensityMetric;
    intensityTargetType: IntensityTargetType;
};
export type CreateSimpleStructuredWorkoutRequest = {
    name: string;
    description?: string;
    structure: SimpleWorkoutStructure;
    tags?: string[];
    notes?: string;
    targetDate?: Date;
    estimatedDuration?: number;
    estimatedDistance?: number;
    estimatedCalories?: number;
    difficulty?: Difficulty;
    activityType?: ActivityType;
    equipment?: string[];
    location?: string;
    weatherConditions?: string;
    personalBest?: boolean;
    coachNotes?: string;
    publiclyVisible?: boolean;
    allowComments?: boolean;
    category?: string;
    subcategory?: string;
    season?: string;
    trainingPhase?: string;
    intensityZone?: number;
    rpeScale?: number;
    heartRateZones?: number[];
    powerZones?: number[];
    paceZones?: number[];
    customFields?: Record<string, unknown>;
};
export type TrainingPeaksClientConfig = {
    baseUrl?: string;
    authMethod?: AuthMethod;
    webAuth?: {
        headless?: boolean;
        timeout?: number;
        executablePath?: string;
    };
    debug?: boolean;
    timeout?: number;
    headers?: Record<string, string>;
    sdkConfig?: Partial<TrainingPeaksConfig>;
};
export type WorkoutStructureValueObject = {
    structure: WorkoutStructureElement[];
    polyline: number[][];
    primaryLengthMetric: LengthMetric;
    primaryIntensityMetric: IntensityMetric;
    primaryIntensityTargetOrRange: IntensityTargetType;
};
//# sourceMappingURL=index.d.ts.map