import { InstructionsLanguage } from './exerciseLocaleUtils';
import { TrainerWorkoutTemplateName, WorkoutDurationMinutes } from './trainer';
import { BugReportQuestionSchema, CreateBugReportRequestBodySchema, postEmailBackofficeSchema, putTrainerWorkoutTemplateIndicesSchema } from './schemas';
import { Language } from './translations';
import { Lookup } from './typeUtils';
import { z } from 'zod';
import { UserWorkout } from './workout';
import { LocalizedExerciseTitles } from './workout/shared';
export * from './schemas';
export * from './constants';
export * from './utils';
export * from './units';
export * from './workout';
export * from './filterExercises';
export * from './setIndicatorUtils';
export * from './workoutVolume';
export * from './coachPlans';
export * from './chat';
export * from './websocket';
export * from './cue';
export * from './muscleHeatmaps';
export * from './muscleSplits';
export * from './notifications';
export * from './routineUtils';
export * from './typeUtils';
export * from './async';
export * from './adminPermissions';
export * from './adjustEventTokens';
export * from './translations';
export * from './exerciseLocaleUtils';
export * from './getVolumeComparison';
export * from './geography';
export type WeightUnit = 'kg' | 'lbs';
export declare const isWeightUnit: (x: string) => x is WeightUnit;
export type DistanceUnit = 'kilometers' | 'miles';
export declare const isDistanceUnit: (x: string) => x is DistanceUnit;
export type DistanceUnitShort = 'km' | 'mi';
export declare const isDistanceUnitShort: (x: string) => x is DistanceUnit;
export type BodyMeasurementUnit = 'cm' | 'in';
export declare const isBodyMeasurementUnit: (x: string) => x is BodyMeasurementUnit;
/** Monday is first */
export declare const orderedWeekdays: readonly ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
export type Weekday = Lookup<typeof orderedWeekdays>;
export declare const isWeekday: (x: string) => x is Weekday;
declare const _timerVolumeOptions: readonly ["off", "low", "normal", "high"];
export type TimerVolumeOption = Lookup<typeof _timerVolumeOptions>;
export declare const isTimerVolumeOption: (x: string) => x is TimerVolumeOption;
declare const _livePRVolumeOption: readonly ["off", "low", "normal", "high"];
export type LivePRVolumeOption = Lookup<typeof _livePRVolumeOption>;
export declare const isLivePRVolumeOption: (x: string) => x is LivePRVolumeOption;
export interface ErrorResponse {
    error: string;
}
export declare const isErrorResponse: (x?: any) => x is ErrorResponse;
/**
 * @deprecated 1.30.4
 */
export interface AccountResponse {
    id: string;
    username: string;
    email: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    profile_pic?: string;
    gift_pro_expiry?: string;
    gympass_user_id?: string;
    is_gympass_plan_active?: boolean;
    follows_push_enabled: boolean;
    likes_push_enabled: boolean;
    comments_push_enabled: boolean;
    comment_mention_push_enabled: boolean;
    comment_discussion_push_enabled: boolean;
    /** @deprecated 1.26.15 */
    comment_replies_push_enabled?: boolean;
    private_profile: boolean;
    follower_count: number;
    following_count: number;
    created_at: string;
    last_workout_at: string;
    accepted_terms_and_conditions: boolean;
    is_coached: boolean;
    birthday?: string;
    sex?: Sex;
    height_cm?: number;
}
export interface UserAccountResponse {
    id: string;
    username: string;
    email: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    profile_pic?: string;
    gift_pro_expiry?: string;
    gympass_user_id?: string;
    is_gympass_plan_active?: boolean;
    is_strava_connected: boolean;
    is_chatgpt_oauth_authorized: boolean;
    country_code?: string;
    city?: string;
    follows_push_enabled: boolean;
    likes_push_enabled: boolean;
    comments_push_enabled: boolean;
    comment_mention_push_enabled: boolean;
    comment_discussion_push_enabled: boolean;
    private_profile: boolean;
    created_at: string;
    last_workout_at: string;
    accepted_terms_and_conditions: boolean;
    /** @deprecated 1.31.1 - use `coach_client_status` instead  */
    is_coached: boolean;
    /** @deprecated 1.31.1 - use `coach_status` instead */
    is_a_coach: boolean;
    coach_client_status?: 'coached-active-plan' | 'coached-inactive-plan';
    coach_status?: 'coach-active-plan' | 'coach-inactive-plan';
    birthday?: string;
    sex?: Sex;
    email_consent: boolean;
    email_verified: boolean;
    height_cm?: number;
    is_hevy_trainer_user: boolean;
}
export interface CoachAppPushTarget {
    type: 'android' | 'ios';
    token: string;
}
declare const _coachRoles: readonly ["member", "admin", "owner"];
export type CoachRole = Lookup<typeof _coachRoles>;
export declare const isCoachRole: (role: any) => role is CoachRole;
export interface CoachAccount {
    id: string;
    username: string;
    email: string;
    full_name?: string;
    profile_pic?: string;
    created_at: string;
    last_workout_at: string;
    accepted_terms_and_conditions: boolean;
    became_coach_at?: string;
    has_hevy_routine: boolean;
    role: CoachRole;
    last_app_launch_at: Date | null;
    join_form_message?: string;
    join_form_banner_image_url?: string;
    client_workouts_logged?: number;
}
export interface CoachTeam {
    title: string;
    id: string;
    members: CoachAccount[];
    image_url?: string;
    enabled_at?: string;
}
export interface FollowCountsResponse {
    follower_count: number;
    following_count: number;
}
export interface AccountUpdate {
    /** `null` = delete the value; `undefined` = do nothing */
    full_name?: string | null;
    description?: string | null;
    website_link?: string | null;
    profile_pic_url?: string | null;
    follows_push_enabled?: boolean;
    likes_push_enabled?: boolean;
    comments_push_enabled?: boolean;
    comment_mention_push_enabled?: boolean;
    comment_discussion_push_enabled?: boolean;
    /** @deprecated 1.26.15 */
    comment_replies_push_enabled?: boolean;
    email_consent?: boolean;
    private_profile?: boolean;
    accepted_terms_and_conditions?: boolean;
    sex?: Sex;
    birthday?: string;
    height_cm?: number;
}
export interface AppleSignUpRequest {
    email?: string;
    appleUserId: string;
    identityToken: string;
    gympassUserId?: string;
    useAuth2_0?: boolean;
}
export interface AppleSignInRequestCoachMobile {
    email?: string;
    appleUserId: string;
    identityToken: string;
    fullName?: string;
}
export interface AppleSignInRequest {
    email?: string;
    appleUserId: string;
    identityToken: string;
    gympassUserId?: string;
    useAuth2_0?: boolean;
}
export interface AppleSignUpWebRequest {
    email?: string;
    identityToken: string;
    gympassUserId?: string;
}
export interface AppleSignInWebRequest {
    email?: string;
    identityToken: string;
    gympassUserId?: string;
}
export interface GoogleSignInRequest {
    email: string;
    googleUserId: string;
    idToken: string;
    source?: 'web';
    gympassUserId?: string;
    useAuth2_0?: boolean;
}
export interface GoogleSignUpRequest {
    email: string;
    googleUserId: string;
    idToken: string;
    source?: 'web';
    gympassUserId?: string;
    useAuth2_0?: boolean;
}
export interface SocialLoginResult extends ClientAuthTokenResponse {
    auth_token: string;
    username: string;
    user_id: string;
    email: string;
    is_new_user: boolean;
}
export interface ClientAuthToken {
    access_token: string;
    refresh_token: string;
    expires_at: Date;
}
export interface ClientRefreshTokenRequest {
    refresh_token: string;
}
export interface ClientAuthTokenResponse {
    access_token: string;
    refresh_token: string;
    expires_at: string;
}
export interface AuthResponse extends ClientAuthTokenResponse {
    user_id: string;
    /**
     * Legacy auth token, will be removed in the future.
     * @deprecated 2.5.3
     */
    auth_token: string;
}
export declare const parseClientAuthTokenResponse: (data: ClientAuthTokenResponse) => ClientAuthToken | null;
export interface UsernameAvailabilityResponse {
    isAvailable: boolean;
    suggestions: string[];
}
export interface CoachLoginResult {
    auth_token: string;
    is_first_login_to_coach_platform: boolean;
}
export interface CoachSocialLoginResult extends SocialLoginResult {
    is_first_login_to_coach_platform: boolean;
}
export interface User {
    id: string;
    email: string;
    auth_token: string;
    username: string;
    verified: boolean;
    profile_pic?: string;
    full_name?: string;
    private_profile: boolean;
    description?: string;
    website_link?: string;
    created_at: string;
}
export interface BackofficeExistingUserResponse {
    state: 'user-account';
    id: string;
    username: string;
    email: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    profile_pic?: string;
    gift_pro_expiry?: string;
    gympass_user_id?: string;
    is_gympass_plan_active?: boolean;
    private_profile: boolean;
    created_at: string;
    last_workout_at: string;
    coach_client_status?: 'coached-active-plan' | 'coached-inactive-plan';
    coach_status?: 'coach-active-plan' | 'coach-inactive-plan';
    coach_username?: string;
    notes: string | null;
    is_banned: boolean;
    metadata: UserMetadataResponse | null;
    shadow_ban_metadata: UserShadowBanMetadata | null;
    shadow_banned_at: string | null;
    gympass_email: string | null;
    paddle_customer_id: string | null;
    public_api_key: string | null;
    limited_discovery: boolean;
    coach_trial_expire_date?: string;
    email_consent: boolean;
    hevy_trainer_program: BackofficeTrainerProgram | null;
}
/**
 * A user has at most one active Hevy Trainer program, on either the v2 schema
 * (program → routines) or the v3 schema (program → templates). The backoffice
 * receives whichever exists as a discriminated union keyed by `schema_version`
 * so the front-end can render each shape.
 */
export type BackofficeTrainerProgram = {
    schema_version: 'v2';
    program: TrainerProgramV2;
} | {
    schema_version: 'v3';
    program: TrainerProgram;
};
export interface BackofficeDeletedUserResponse {
    state: 'deleted-account';
    id: string;
    username: string;
    email: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    profile_pic?: string;
    created_at: string;
    notes: string | null;
    metadata: UserMetadataResponse | null;
}
export type BackofficeUserResponse = BackofficeExistingUserResponse | BackofficeDeletedUserResponse;
export type BackofficeFeaturedUser = Pick<BackofficeExistingUserResponse, 'id' | 'username' | 'profile_pic' | 'private_profile' | 'last_workout_at'> & {
    followers_count: number;
};
export type BanType = 'suspicious' | 'warned' | 'restricted';
export type BackofficeShadowBannedUser = Pick<BackofficeExistingUserResponse, 'id' | 'username' | 'profile_pic'> & {
    shadow_ban_metadata: UserShadowBanMetadata;
    shadow_banned_at: string;
    ban_type: BanType;
    backoffice_notes?: string;
};
export interface BackofficeUserComment {
    comment_id: number;
    workout_username: string;
    workout_short_id: string;
    comment_date: string;
    is_archived: boolean;
    comment_text: string;
}
export interface BackofficeAccountUpdate {
    username?: string;
    email?: string;
    description?: string;
    notes?: string;
    /** `null` means we're unlinking the user's Gympass account */
    gympass_email?: string | null;
    gympass_subscription_active?: boolean;
    gympass_account?: {
        id: string;
        email: string;
        country_code?: string;
    };
    limited_discovery?: boolean;
    delete_profile_pic?: boolean;
    delete_link?: boolean;
}
export interface BackofficeSuggestedUsersResponse {
    users: SuggestedUser[];
}
export interface BackofficeBlockedUsersResponse {
    users: {
        id: string;
        username: string;
        profile_pic: string | null;
    }[];
}
export interface IPBlacklistEntry {
    ip_range: string;
    comment: string;
    created_at: string;
}
export interface GetIPBlacklistResponse {
    ip_blacklist: IPBlacklistEntry[];
}
export interface BackofficeReportedUserSummary {
    user_id: string;
    username: string;
    num_reports: number;
    last_reported_at: string;
    signed_up_at: string;
    app_language: string;
    platform: string;
    platform_version: string;
    app_version: string;
    geoip_country: string;
    geoip_city: string;
    geoip_timezone: string;
    last_ip: string;
}
export interface BackofficeGetReportedUserOverviewResponse {
    reported_users: BackofficeReportedUserSummary[];
}
export interface CoachsClientData {
    id: string;
    email: string;
    username: string;
    profile_pic: string | null;
    full_name: string | null;
    last_workout_at: string;
    notes: string | null;
    custom_exercises: CustomExercise[];
    user_preferences: UserPreferences | null;
    user_created_at: string;
    coaching_started_at: string;
    is_sample_user: boolean;
    client_configuration: ClientConfiguration;
    coach_id: string;
    program?: MinimalClientProgram;
}
export interface MinimalClientProgram {
    title: string | null;
    duration_days: number | null;
    start_date: string | null;
    id: string;
}
export interface CoachsLead {
    lead_full_name: string;
    lead_email: string;
    lead_message: string;
    lead_user_id?: string;
    lead_coach_id: string;
    created_at: string;
}
export type CoachPlanUpdateType = 'pause' | 'cancel' | 'change' | 'resume';
export interface CoachPlanUpdateRequest {
    planUpdateType: CoachPlanUpdateType;
    newPlanId?: string;
}
export declare const DefaultClientConfiguration: ClientConfiguration;
export interface ClientConfiguration {
    is_chat_enabled: boolean;
    are_notifications_enabled: boolean;
}
export interface ClientsCoachData {
    username: string;
    profile_pic: string | null;
    email: string;
    full_name: string | null;
    coaching_since: string;
    coach_id: string;
    coach_conversation_id?: string;
    client_configuration: ClientConfiguration;
    is_paying_coach: boolean;
}
export interface WebNotificationConfiguration {
    client_completes_workout: boolean;
    client_sends_message: boolean;
    client_adds_measurement: boolean;
}
export type WebNotificationConfigurationType = 'client_completes_workout' | 'client_sends_message' | 'client_adds_measurement';
export interface EmailNotificationConfiguration {
    client_completes_workout: boolean;
    client_sends_message: boolean;
    client_adds_measurement: boolean;
    program_finishes_next_week: boolean;
}
export type EmailNotificationConfigurationType = 'client_completes_workout' | 'client_sends_message' | 'client_adds_measurement' | 'program_finishes_next_week';
export interface MobileNotificationConfiguration {
    client_sends_message: boolean;
}
export interface CoachJoinFormData {
    coachUsername: string;
    coachFullname?: string;
    joinMessage?: string;
    joinImageUrl?: string;
    coachProfileImageUrl?: string;
}
export interface CoachAccountConfiguration {
    enable_chat_for_new_clients: boolean;
    enable_notifications_for_new_clients: boolean;
    weight_unit?: WeightUnit;
    distance_unit?: DistanceUnit;
    body_measurement_unit?: BodyMeasurementUnit;
    default_rest_timer_seconds?: number;
    is_rpe_enabled_for_new_routines?: boolean;
    first_weekday?: Weekday;
    default_rep_input_type?: RepInputType;
    web_notifications?: WebNotificationConfiguration;
    email_notifications?: EmailNotificationConfiguration;
    mobile_notifications?: MobileNotificationConfiguration;
}
export interface UserShadowBanMetadata {
    manual_ban: boolean;
    reason: string;
    username?: string | null;
    full_name?: string | null;
    email?: string | null;
    description?: string | null;
    website_link?: string | null;
    profile_pic_url?: string | null;
    recaptcha_score?: number | null;
}
declare const _supportedProStores: readonly ["app_store", "play_store", "stripe", "hevy-gift", "gympass", "paddle", "hevy-coach"];
type UserHevyProSubcriptionStore = Lookup<typeof _supportedProStores>;
export interface UserHevyProSubcription {
    is_pro: boolean;
    active_subscription?: {
        managing_store: UserHevyProSubcriptionStore;
        type: 'monthly' | 'yearly' | 'lifetime' | 'custom';
        expires_date?: string;
        grace_period_expires_date?: string | null;
        /**
         * Set if the user has paused/cancelled their subscription
         */
        subscription_cancels_on?: string;
    };
}
export interface UserPreferences {
    username: string;
    language?: Language;
    weight_unit?: WeightUnit;
    distance_unit?: DistanceUnit;
    body_measurement_unit?: BodyMeasurementUnit;
    first_weekday?: Weekday;
    default_rest_timer_seconds?: number;
    workout_keep_awake?: boolean;
    disabled_review_request?: boolean;
    superset_scrolling?: boolean;
    plate_calculator_enabled?: boolean;
    previous_workout_values_from_routine?: boolean;
    rpe_enabled?: boolean;
    timer_volume?: TimerVolumeOption;
    live_pr_volume?: LivePRVolumeOption;
    inline_set_timer_enabled?: boolean;
    default_workout_visibility_public?: boolean;
    default_workout_biometrics_visibility_public?: boolean;
    /** Only updateable by the backend within a special API */
    volume_includes_warmup_sets?: boolean;
}
export type UpdateUserPreferencesRequest = Omit<UserPreferences, 'username' | 'volume_includes_warmup_sets'>;
export type FollowingStatus = 'not-following' | 'following' | 'requested';
export type FollowingStatusMap = {
    [id: string]: Omit<FollowingStatus, 'not-following'>;
};
export type FollowingStatusesResponse = {
    [id: string]: 'following' | 'requested';
};
export interface FollowRequest {
    id: number;
    username: string;
    profile_pic?: string;
}
export interface SearchUser {
    id: string;
    profile_pic?: string;
    username: string;
    full_name: string;
    following_status: FollowingStatus;
    private_profile: boolean;
    verified: boolean;
}
export interface CoachInviteSearchUser {
    id: string;
    profile_pic?: string;
    username: string;
    email?: string;
    full_name: string | null;
}
export interface WeeklyWorkoutDuration {
    week_start_date: string;
    week_end_date: string;
    total_seconds: number;
}
export interface RoutineMetadata {
    id: string;
    short_id: string;
    title: string;
}
export type PreviewMutualUser = {
    username: string;
    profile_pic: string | null;
};
export interface UserProfile {
    username: string;
    verified: boolean;
    subscribed: boolean;
    profile_pic?: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    workout_count: number;
    following_status: FollowingStatus;
    is_followed_by_requester: boolean;
    private_profile: boolean;
    is_blocked: boolean;
    follower_count: number;
    following_count: number;
    routines: RoutineMetadata[];
    weekly_workout_durations: WeeklyWorkoutDuration[];
    mutual_followers: PreviewMutualUser[];
}
export interface PublicUserProfile {
    private_profile: boolean;
    username: string;
    verified: boolean;
    profile_pic?: string;
    full_name?: string;
    description?: string;
    website_link?: string;
    workout_count: number;
    follower_count: number;
    following_count: number;
    routines: RoutineMetadata[];
    weekly_workout_durations: WeeklyWorkoutDuration[];
    last_workout?: UserWorkout;
}
export declare const coreMuscles: readonly ["abdominals"];
export declare const shoulderMuscles: readonly ["shoulders"];
export declare const armMuscles: readonly ["biceps", "triceps", "forearms"];
export declare const legMuscles: readonly ["quadriceps", "hamstrings", "calves", "glutes", "abductors", "adductors"];
export declare const backMuscles: readonly ["lats", "upper_back", "traps", "lower_back"];
export declare const chestMuscles: readonly ["chest"];
export declare const miscellaneousMuscles: readonly ["cardio", "neck", "full_body", "other"];
export declare const simplifiedMuscleGroups: readonly ["core", "shoulders", "arms", "legs", "back", "chest"];
export type SimplifiedMuscleGroup = Lookup<typeof simplifiedMuscleGroups>;
export declare const isSimplifiedMuscleGroup: (x: string) => x is SimplifiedMuscleGroup;
export declare const muscleGroups: readonly ["abdominals", "shoulders", "biceps", "triceps", "forearms", "quadriceps", "hamstrings", "calves", "glutes", "abductors", "adductors", "lats", "upper_back", "traps", "lower_back", "chest", "cardio", "neck", "full_body", "other"];
export type MuscleGroup = Lookup<typeof muscleGroups>;
export declare const isMuscleGroup: (x: string) => x is MuscleGroup;
export declare const simplifiedMuscleGroupToMuscleGroups: Record<SimplifiedMuscleGroup, readonly MuscleGroup[]>;
/**
 * Equipment
 */
export declare const equipments: readonly ["none", "barbell", "dumbbell", "kettlebell", "machine", "plate", "resistance_band", "suspension", "other"];
export type Equipment = Lookup<typeof equipments>;
export declare const isEquipment: (x: string) => x is Equipment;
export declare const exerciseRepTypes: readonly ["weight_reps", "reps_only", "bodyweight_reps", "bodyweight_assisted_reps"];
/**
 * ExerciseRepType
 *
 * weight_reps = Bench Press
 * bodyweight_reps = Pull ups (Weighted)
 * bodyweight_assisted_reps = Pull Ups (Assisted)
 * reps_only = Pull ups
 */
export type ExerciseRepType = Lookup<typeof exerciseRepTypes>;
export declare const isExerciseRepType: (x: any) => x is ExerciseRepType;
export declare const exerciseTypes: readonly ["weight_reps", "reps_only", "bodyweight_reps", "bodyweight_assisted_reps", "duration", "weight_duration", "distance_duration", "short_distance_weight", "floors_duration", "steps_duration"];
export type ExerciseType = Lookup<typeof exerciseTypes>;
export declare const isExerciseType: (x: any) => x is ExerciseType;
export type CustomExerciseType = Exclude<ExerciseType, 'floors_duration' | 'steps_duration'>;
export declare const customExericseTypes: CustomExerciseType[];
export declare const isCustomExerciseType: (x: any) => x is CustomExerciseType;
export declare const trainingGoals: readonly ["strength", "build_muscle", "fat_loss"];
export declare const trainingLevels: readonly ["beginner", "intermediate", "advanced"];
export declare const exerciseCategories: readonly ["isolation", "compound", "assistance-compound"];
export declare const restTimerLengths: readonly ["short", "medium", "long"];
export declare const cardioPreferences: readonly ["no-cardio", "workout-start", "workout-end"];
export type TrainingGoal = Lookup<typeof trainingGoals>;
export type TrainingLevel = Lookup<typeof trainingLevels>;
export type ExerciseCategory = Lookup<typeof exerciseCategories>;
export type RestTimerLength = (typeof restTimerLengths)[number];
export type CardioPreference = (typeof cardioPreferences)[number];
/** @deprecated Use GranularEquipment instead */
export type TrainerProgramEquipment = Extract<Equipment, 'barbell' | 'dumbbell' | 'machine'>;
/** @deprecated Use granularEquipments instead */
export declare const trainerProgramEquipments: readonly ["barbell", "dumbbell", "machine"];
export declare const granularEquipments: readonly ["barbell", "dumbbell", "kettlebell", "plate", "medicine_ball", "ez_bar", "landmine", "trap_bar", "pullup_bar", "dip_bar", "squat_rack", "flat_bench", "adjustable_bench", "dual_cable_machine", "single_cable_machine", "lat_pulldown_cable", "leg_press_machine", "smith_machine", "t_bar", "plate_machines", "stack_machines", "treadmill", "elliptical_trainer", "rowing_machine", "spinning", "stair_machine", "air_bike", "suspension_band", "resistance_band", "battle_rope", "rings", "jump_rope"];
export type GranularEquipment = Lookup<typeof granularEquipments>;
export declare const isGranularEquipment: (x: string) => x is GranularEquipment;
export declare const weeklyTrainingFrequencies: readonly [1, 2, 3, 4, 5, 6];
export type WeeklyTrainingFrequency = Lookup<typeof weeklyTrainingFrequencies>;
/**
 * Base properties that all exercise templates must have
 */
export interface BaseExerciseTemplate {
    id: string;
    title: string;
    exercise_type: ExerciseType;
    muscle_group: MuscleGroup;
    other_muscles: MuscleGroup[];
    equipment_category: Equipment;
    is_archived: boolean;
    is_custom: boolean;
    priority: number;
    volume_doubling_supported?: boolean;
    /** Exercise asset URL */
    url?: string;
    thumbnail_url?: string;
    media_type?: 'video' | 'image';
}
/**
 * Library exercises are predefined exercises that come with the app
 * They are stored on the database and downloaded to the client
 * They have additional properties like translations, leaderboard eligibility, etc.
 */
export interface LibraryExercise extends BaseExerciseTemplate, LocalizedExerciseTitles {
    is_custom: false;
    aka?: string;
    manual_tag?: string;
    comparable_exercise?: boolean;
    leaderboard_exercise?: boolean;
    hundred_percent_bodyweight_exercise?: boolean;
    strength_level_exercise?: boolean;
    localised_instructions?: {
        [language in InstructionsLanguage]?: string;
    };
    goal: TrainingGoal[] | undefined;
    level: TrainingLevel[] | undefined;
    category: ExerciseCategory | undefined;
    granular_equipments: GranularEquipment[] | undefined;
    url_female?: string;
    thumbnail_url_female?: string;
}
/**
 * Custom exercises are user-created templates with minimal properties
 */
export interface CustomExercise extends BaseExerciseTemplate {
    is_custom: true;
    exercise_type: CustomExerciseType;
    priority: 10;
    /** @deprecated 2.2.2 */
    custom_exercise_image_url?: string;
    media?: CustomExerciseMedia;
    /** Used for Hevy Coach: in Hevy Coach, changes to a parent template propagate to children, and clients can't edit the children */
    parent_exercise_template_id?: string;
}
declare const _setPersonalRecordTypes: readonly ["best_weight", "best_reps", "best_volume", "best_1rm", "best_duration", "best_distance", "most_floors", "most_steps"];
export type SetPersonalRecordType = Lookup<typeof _setPersonalRecordTypes>;
export declare const isSetPersonalRecordType: (x: string) => x is SetPersonalRecordType;
export interface SetPersonalRecord {
    exercise_template_id: string;
    type: SetPersonalRecordType;
    record: number;
}
export declare const validRpeValues: readonly [6, 7, 7.5, 8, 8.5, 9, 9.5, 10];
export type RPE = Lookup<typeof validRpeValues>;
export declare const isRPE: (x: number) => x is RPE;
declare const _setTypes: readonly ["warmup", "normal", "failure", "dropset"];
export type SetType = Lookup<typeof _setTypes>;
export declare const isSetType: (x: string) => x is SetType;
export interface RepRange {
    start: number | null;
    end: number | null;
}
export interface StrictRepRange extends RepRange {
    start: number;
    end: number;
}
export interface WorkoutComment {
    id: number;
    username: string;
    verified: boolean;
    full_name?: string;
    profile_pic?: string;
    comment: string;
    created_at: string;
    like_count: number;
    is_liked_by_user: boolean;
    parent_comment_id?: number;
}
export interface WorkoutImage {
    type: 'image';
    url: string;
}
export interface WorkoutVideo {
    type: 'video';
    url: string;
    thumbnail_url: string;
}
export type WorkoutMedia = WorkoutImage | WorkoutVideo;
export type PreviewWorkoutLike = {
    username: string;
    profile_pic: string;
};
export interface CustomExerciseImage {
    type: 'image';
    image_url: string;
}
export interface CustomExerciseVideo {
    type: 'video';
    video_url: string;
    video_preview_image_url: string;
}
export type CustomExerciseMedia = CustomExerciseImage | CustomExerciseVideo;
/** @deprecated 3.1.4, succeeded by {@link GetDataImportResponse} */
export type WorkoutDataImporterReport = {
    state: 'idle';
} | {
    state: 'waiting';
} | {
    state: 'import-exercises';
} | {
    state: 'import-workouts';
    current: number;
    total: number;
} | {
    state: 'rollback';
} | never;
export type GetDataImportResponse = {
    status: 'not-imported';
} | {
    status: 'imported';
    source: string;
    workout_count: number;
    workout_exercise_count: number;
    oldest_workout_date: string;
    newest_workout_date: string;
    import_completed_at: string;
} | {
    status: 'waiting-for-job';
    source: string;
} | {
    status: 'importing-exercises';
    source: string;
} | {
    status: 'importing-workouts';
    source: string;
    current: number;
    total: number;
} | {
    status: 'rolling-back';
    source: string;
} | {
    status: 'error';
    source: string;
    error: string;
} | never;
export declare const isHeartRateSamples: (x: any) => x is HeartRateSample[];
export declare const isWorkoutBiometrics: (x: any) => x is WorkoutBiometrics;
export interface WorkoutBiometrics {
    total_calories?: number;
    heart_rate_samples?: HeartRateSample[];
    average_heart_rate?: number;
}
export interface HeartRateSample {
    timestamp_ms: number;
    bpm: number;
}
export interface GeospatialPoint {
    timestamp: number;
    latitude: number;
    longitude: number;
    elevation: number;
}
/** Routines */
export interface RoutineSet {
    index: number;
    indicator: SetType;
    weight_kg?: number | null;
    reps?: number | null;
    distance_meters?: number | null;
    duration_seconds?: number | null;
    custom_metric?: number | null;
    rpe?: RPE | null;
    rep_range?: RepRange;
}
export interface RoutineExercise extends LocalizedExerciseTitles {
    id: string;
    /** This is the username of the exercise_template */
    username: string;
    exercise_template_id: string;
    warmup_set_count: number;
    normal_set_count: number;
    title: string;
    muscle_group: MuscleGroup;
    other_muscles: MuscleGroup[];
    exercise_type: ExerciseType;
    equipment_category: Equipment;
    sets: RoutineSet[];
    notes?: string | null;
    url?: string | null;
    custom_exercise_image_url?: string | null;
    parent_exercise_template_id?: string | null;
    thumbnail_url?: string | null;
    media_type?: string;
    superset_id: number | null;
    rest_seconds: number | null;
    input_modifier?: 'rep-range';
}
export interface BaseRoutine {
    id: string;
    short_id: string;
    parent_routine_id: string | null;
    title: string;
    username: string | null;
    profile_pic: string | null | undefined;
    exercises: RoutineExercise[];
    updated_at: string;
    index: number | null;
    folder_id: number | null;
    program_id: string | null;
    coach_id: string | null;
    notes: string | null;
    coach_force_rpe_enabled: boolean;
    hevy_trainer_program_id: string | null;
    created_at: string;
}
export interface Routine extends BaseRoutine {
    username: string;
    coach_id: null;
}
/** @deprecated Use TrainerWorkoutTemplate instead */
export interface TrainerRoutine extends Routine {
    hevy_trainer_program_id: string;
    program_id: null;
    coach_force_rpe_enabled: false;
    folder_id: null;
}
/** @deprecated Use TrainerWorkoutTemplate instead */
export declare const isTrainerRoutine: (routine: BaseRoutine) => routine is TrainerRoutine;
export type CoachsShallowLibraryRoutine = Omit<BaseRoutine, 'exercises' | 'profile_pic' | 'hevy_trainer_program_id' | 'username'>;
export interface CoachesRoutine extends BaseRoutine {
    coach_id: string;
    username: null;
    hevy_trainer_program_id: null;
}
export interface CoachAndCoachsClientsRoutineSyncResponse {
    updated: BaseRoutine[];
    deleted: string[];
}
export interface CreateSampleClientResponse {
    auth_token: string;
}
export interface RoutineSync {
    updated: Routine[];
    deleted: string[];
    isMore: boolean;
    updated_at?: string;
}
export interface RoutineUpdate {
    title: string;
    exercises: RoutineUpdateExercise[];
    parent_routine_id?: string;
    folder_id: number | null;
    index: number;
    program_id: string | null;
    notes: string | null;
    coach_force_rpe_enabled?: boolean;
}
export interface PostRoutineRequest extends RoutineUpdate {
    clientId: string;
}
export interface RoutineUpdateExercise {
    exercise_template_id: string;
    superset_id?: number | null;
    rest_seconds?: number | null;
    sets: RoutineUpdateSet[];
    notes?: string | null;
    input_modifier?: 'rep-range';
}
export interface RoutineUpdateSet {
    index: number;
    indicator: SetType;
    weight_kg?: number | null;
    reps?: number | null;
    distance_meters?: number | null;
    duration_seconds?: number | null;
    custom_metric?: number | null;
    rpe?: RPE | null;
    rep_range?: RepRange;
}
export interface RoutineFolderLocationUpdate {
    folderId: number;
    index: number;
}
export interface RoutineLocationUpdate {
    routineId: string;
    folderId: number | null;
    index: number;
}
export interface RoutineFolder {
    id: number;
    title: string;
    index: number;
    created_at: string;
    updated_at: string;
}
export interface ShareableRoutineFolder {
    id: number;
    title: string;
    username: string;
    profile_pic?: string;
    routines: Routine[];
}
export interface Program {
    id: string;
    title: string;
    created_at: string;
    coach_id: string;
    client_id: string | null;
    template_program_id: string | null;
    folder_id: number | null;
    index: number | null;
    notes: string | null;
    duration_days: number | null;
    start_date: string | null;
}
export interface ProgramUpdate {
    title: string;
    template_program_id: string | null;
    client_id: string | null;
    folder_id: number | null;
    notes: string | null;
    duration_days: number | null;
    start_date: string | null;
}
export interface PostAssignProgramRequest {
    title: string;
    notes: string | null;
    duration_days: number | null;
    start_date: string | null;
    template_program_id: string;
    client_ids: string[];
}
export interface ProgramLocationUpdate {
    index: number;
    program_id: string;
    folder_id: number | null;
}
export interface ProgramFolder {
    created_at: string;
    id: number;
    index: number;
    title: string;
    coach_id: string;
}
export interface ProgramFolderLocationUpdate {
    index: number;
    folder_id: number;
}
export interface ClientInvite {
    coach_name: string | null;
    coach_profile_pic: string | null;
    coach_username: string;
}
export interface GetInviteResponse {
    coach_name?: string;
    coach_username: string;
    coach_profile_pic?: string;
    invitee_email: string;
    invitee_username?: string;
}
export interface CoachClientInvite {
    client_id: string | null;
    coach_id: string;
    created_at: Date;
    invitee_email: string;
    invitee_username: string | null;
    invitee_profile_pic: string | null;
    invitee_full_name: string | null;
    short_id: string;
    declined_at: Date | null;
}
export interface OutstandingInvitesForCoachResponse {
    invites: CoachClientInvite[];
}
export interface CoachTeamInvite {
    invitee_user_id: string | null;
    inviter_user_id: string;
    created_at: Date;
    invitee_email: string;
    invitee_username: string | null;
    invitee_profile_pic: string | null;
    invitee_full_name: string | null;
    invitee_role: CoachRole;
    short_id: string;
    declined_at: Date | null;
}
export interface GetTeamInviteResponse {
    invitee_email: string;
    invitee_username?: string;
    team_title: string;
    team_image_url?: string;
}
export interface OutstandingInvitesForCoachTeamResponse {
    invites: CoachTeamInvite[];
}
export interface TrainerWorkoutTemplateResistanceExercise {
    kind: 'resistance';
    id: string;
    exercise_template_id: string;
    index: number;
    set_count: number;
    warmup_set_count: number;
    rep_range: StrictRepRange;
    rest_seconds: number;
}
export interface TrainerWorkoutTemplateCardioExercise {
    kind: 'cardio';
    id: string;
    exercise_template_id: string;
    index: number;
    set_count: 1;
    duration_seconds: number;
}
export interface TrainerWorkoutTemplateOtherExercise {
    kind: 'other';
    id: string;
    exercise_template_id: string;
    index: number;
    set_count: number;
}
export type TrainerWorkoutTemplateExercise = TrainerWorkoutTemplateResistanceExercise | TrainerWorkoutTemplateCardioExercise | TrainerWorkoutTemplateOtherExercise;
export interface TrainerWorkoutTemplate {
    id: string;
    hevy_trainer_program_id: string;
    index: number;
    name: TrainerWorkoutTemplateName;
    exercises: TrainerWorkoutTemplateExercise[];
}
export interface TrainerProgram {
    id: string;
    schema_version: 'v3';
    created_at: string;
    updated_at: string;
    level: TrainingLevel;
    goal: TrainingGoal;
    equipments: GranularEquipment[];
    weekly_frequency: WeeklyTrainingFrequency;
    templates: TrainerWorkoutTemplate[];
    focus_muscle?: SimplifiedMuscleGroup;
    next_workout_index: number;
    workout_duration_minutes: WorkoutDurationMinutes;
    rest_timer_length: RestTimerLength;
    cardio_preference: CardioPreference;
}
export type TrainerWorkoutTemplateExerciseInput = Omit<TrainerWorkoutTemplateResistanceExercise, 'id'> | Omit<TrainerWorkoutTemplateCardioExercise, 'id'> | Omit<TrainerWorkoutTemplateOtherExercise, 'id'>;
export interface PostTrainerWorkoutTemplate {
    name: TrainerWorkoutTemplateName;
    index: number;
    exercises: TrainerWorkoutTemplateExerciseInput[];
}
export interface UpdateTrainerWorkoutTemplate extends PostTrainerWorkoutTemplate {
    id: string;
}
export interface PostTrainerProgramRequestBody {
    program: {
        version: 3;
        title: string;
        level: TrainingLevel;
        goal: TrainingGoal;
        equipments: GranularEquipment[];
        weekly_frequency: WeeklyTrainingFrequency;
        focus_muscle?: SimplifiedMuscleGroup;
        next_workout_index?: number;
        workout_duration_minutes: WorkoutDurationMinutes;
        rest_timer_length: RestTimerLength;
        cardio_preference: CardioPreference;
        templates: PostTrainerWorkoutTemplate[];
    };
    /**
     * Whether to delete (archive) the caller's currently active Hevy Trainer
     * program before creating the new one. Creating a program implicitly
     * replaces any active program, so this must be set explicitly:
     * - `false` — fail with `ActiveProgramExists` (409) if one already exists.
     * - `true` — archive the existing active program, then create the new one.
     */
    deleteActiveProgram: boolean;
}
export interface UpdateTrainerProgramRequestBody {
    program: {
        version: 3;
        programId: string;
        level: TrainingLevel;
        goal: TrainingGoal;
        equipments: GranularEquipment[];
        weekly_frequency: WeeklyTrainingFrequency;
        focus_muscle?: SimplifiedMuscleGroup;
        next_workout_index?: number;
        workout_duration_minutes: WorkoutDurationMinutes;
        rest_timer_length: RestTimerLength;
        cardio_preference: CardioPreference;
        templates: UpdateTrainerWorkoutTemplate[];
    };
}
/** @deprecated Use TrainerProgram instead */
export interface TrainerProgramV2 {
    id: string;
    created_at: string;
    updated_at: string;
    title: string;
    level: TrainingLevel;
    goal: TrainingGoal;
    equipments: GranularEquipment[];
    weekly_frequency: WeeklyTrainingFrequency;
    routines: TrainerRoutine[];
    focus_muscle?: SimplifiedMuscleGroup;
    next_workout_index: number;
    workout_duration_minutes: WorkoutDurationMinutes;
    rest_timer_length: RestTimerLength;
    cardio_preference: CardioPreference;
}
export declare const measurementsList: readonly ["weight_kg", "lean_mass_kg", "fat_percent", "neck_cm", "shoulder_cm", "chest_cm", "left_bicep_cm", "right_bicep_cm", "left_forearm_cm", "right_forearm_cm", "abdomen", "waist", "hips", "left_thigh", "right_thigh", "left_calf", "right_calf"];
type MeasurementProperties = {
    [key in (typeof measurementsList)[number]]?: number;
};
export type BodyMeasurementKey = Lookup<typeof measurementsList>;
export declare const isBodyMeasurementKey: (key: string) => key is BodyMeasurementKey;
export interface BodyMeasurement extends MeasurementProperties {
    id: number;
    date: string;
    created_at: string;
    picture_url?: string;
}
export type PostBodyMeasurementRequest = Omit<BodyMeasurement, 'id' | 'created_at'>;
export interface CreateCustomExerciseRequest {
    title: string;
    muscle_group: MuscleGroup;
    other_muscles: MuscleGroup[];
    exercise_type: CustomExerciseType;
    equipment_category: Equipment;
    /** @deprecated 2.2.4*/
    custom_exercise_image_url?: string;
    media?: CustomExerciseMedia;
    thumbnail_url?: string;
    /** if set, the template will be related to the coach, not via username */
    coach_id?: string;
}
export interface GetVolumeDoublingEnabledExercisesResponse {
    exerciseTemplateIds: string[];
}
export interface PostVolumeDoublingEnabledExercisesRequest {
    exerciseTemplateIds: string[];
}
export interface UpdateCustomExerciseRequest {
    id: string;
    title: string;
    muscle_group: MuscleGroup;
    other_muscles: MuscleGroup[];
    equipment_category: Equipment;
    /** @deprecated 2.2.4*/
    custom_exercise_image_url?: string;
    media?: CustomExerciseMedia;
    thumbnail_url?: string;
}
export type ExerciseTemplateCustomizationAttachmentUrlType = 'mp4_video' | 'youtube';
export interface ExerciseTemplateCustomization {
    exercise_template_id: string;
    instructions?: string;
    video_url?: string;
    video_url_type?: ExerciseTemplateCustomizationAttachmentUrlType;
}
export interface CreateOrUpdateExerciseTemplateCustomizationRequest {
    exercise_template_id: string;
    instructions?: string;
    video_url?: string;
}
export interface ClientRecentExerciseData {
    exercise_template_id: string;
    date_used: number;
}
export type WeightRepComparisonMetric = 'one_rep_max' | 'best_weight' | 'best_set_volume';
export type RepsOnlyComparisonMetric = 'best_set_reps' | 'best_session_reps';
export type ComparisonMetric = WeightRepComparisonMetric | RepsOnlyComparisonMetric;
export type ExerciseMetricComparison = OneRepMaxMetricComparison | BestWeightMetricComparison | BestSetVolumeMetricComparison | RepsOnlyExerciseMetricComparison;
interface BaseWeightRepExerciseMetricComparison {
    type: 'weight_rep';
    metric_id: WeightRepComparisonMetric;
    current_user_value_kg: number;
    other_user_value_kg: number;
}
export interface OneRepMaxMetricComparison extends BaseWeightRepExerciseMetricComparison {
    metric_id: 'one_rep_max';
}
export interface BestSetVolumeMetricComparison extends BaseWeightRepExerciseMetricComparison {
    metric_id: 'best_set_volume';
}
export interface BestWeightMetricComparison extends BaseWeightRepExerciseMetricComparison {
    metric_id: 'best_weight';
    current_user_rank?: number;
    other_user_rank?: number;
}
export interface RepsOnlyExerciseMetricComparison {
    type: 'reps_only';
    metric_id: RepsOnlyComparisonMetric;
    current_user_value_reps: number;
    other_user_value_reps: number;
}
export interface UserWeeklyWorkoutDuration {
    week_start_date: string;
    week_end_date: string;
    total_seconds: number;
}
export interface GeneratePasswordRecoveryTokenResult {
    result: 'success';
}
export interface PromoResponse {
    endDate: string;
    feedCellTitle: {
        en: string;
        es: string;
        de: string;
        fr: string;
        it: string;
        pt: string;
        tr: string;
        ru: string;
        ja: string;
        ko: string;
        zh_CN: string;
        zh_TW: string;
    };
}
export interface HevyCoachLaunchStatusResponse {
    endDate: string;
}
export interface UserExerciseSet {
    workout_id: string;
    workout_short_id: string;
    workout_title: string;
    exercise_template_id: string;
    created_at: string;
    start_time: number;
    end_time: number;
    weight_kg: number | null;
    reps: number | null;
    duration_seconds: number | null;
    distance_meters: number | null;
    rpe: RPE | null;
    user_bodyweight_kg: number | null;
    custom_metric: number | null;
    geospatial_data: GeospatialPoint[] | null;
}
export type SetCountMuscleSplitResponse = {
    [key in MuscleGroup]: number;
};
export type ComparableExerciseTemplatesResponse = Array<{
    exercise_template_id: string;
}>;
export interface UserProfileCompareResponse {
    current_user: {
        workout_count: number;
        volume_kg: number;
        duration_seconds: number;
    };
    other_user: {
        workout_count: number;
        volume_kg: number;
        duration_seconds: number;
    };
}
export interface ExerciseLeaderboardEntry {
    username: string;
    best_weight_kg: number;
    profile_pic: string | null;
    workout_id: string;
    is_private: boolean;
    set_id: string;
    is_outlier: boolean;
}
export interface ExerciseLeaderboardResponse {
    leaderboard_entries: ExerciseLeaderboardEntry[];
}
export type StrengthLevel = 'beginner' | 'intermediate' | 'advanced' | 'elite';
export interface GetStrengthLevelParams {
    sex: Omit<Sex, 'other'>;
    best_1rm_kg: number;
    exercise_template_id: string;
    age: number;
    bodyweight_kg: number;
}
export interface StrengthLevelResponse {
    percentile: number | null;
}
export interface ServerYearInReview {
    supporters: Array<{
        username: string;
        like_count: number;
        profile_pic?: string;
    }>;
}
export type PlateCalculatorBar = {
    id: number;
    title: string;
    weight: number;
    unit: WeightUnit;
};
export type PlateCalculatorPlate = {
    id: number;
    weight: number;
    unit: WeightUnit;
};
export interface WarmupSet {
    percentWeight: number;
    reps: number;
}
export interface WarmupCalculatorData {
    warmupCalculatorEnabled: boolean;
    plateRoundingSettingKg: number;
    plateRoundingSettingLbs: number;
    dumbbellRoundingSettingKg: number;
    dumbbellRoundingSettingLbs: number;
    warmupSets: WarmupSet[];
}
export interface RecalculateSetPRProgress {
    numWorkoutsProcessed: number;
    numWorkoutsTotal: number;
}
export type RecalculateSetPRStatusResponse = {
    type: 'ready';
} | {
    type: 'busy';
    progress: RecalculateSetPRProgress;
} | {
    type: 'error';
};
export interface ExerciseTemplateUnit {
    id: number;
    exercise_template_id: string;
    weight_unit: WeightUnit;
}
export interface UserMetadataRequest {
    appLanguage: string;
    platform: string;
    platformVersion: string;
    appVersion: string;
    securityId?: string;
    googleAdId?: string;
    appleIdfv?: string;
    adjustAdId?: string;
    timezone?: string;
}
export type NetworkType = 'wifi' | 'cellular' | 'unknown';
export interface UserMetadataResponse {
    created_at: string;
    updated_at: string;
    app_language: string | null;
    platform: string | null;
    platform_version: string | null;
    app_version: string | null;
    geoip_country: string | null;
    geoip_city: string | null;
    geoip_timezone: string | null;
    security_id: string | null;
    adjust_adid: string | null;
    google_adid: string | null;
    apple_idfv: string | null;
    last_ip: string | null;
    timezone: string | null;
}
export interface NetworkInfoRequest {
    networkType: NetworkType;
}
type CommercialGym = {
    type: 'commercial';
    id: string;
    name: string;
    fullAddress: string;
    city: string;
    latitude: number;
    longitude: number;
};
export type Gym = CommercialGym;
export interface StripePrice {
    product_id: string;
    billing_period: 'month' | 'year' | 'pay-once';
    price_usd: number;
}
export interface StripePromoCodeDetails {
    product_id: string;
    percent_off: number;
}
export interface StripeCheckoutSessionRequest {
    lookup_key: string;
    success_url: string;
    cancel_url: string;
    promo_code?: string;
}
export interface StripeCheckoutSessionResponse {
    url: string;
}
export interface PaddlePrice {
    paddle_price_id: string;
    billing_period: 'month' | 'year' | 'lifetime';
    price_usd: number;
}
export type BillingPeriod = 'lifetime' | 'month' | 'year';
export interface PaddlePromoCodeDetails {
    code: string;
    percent_off: number;
    billing_period: BillingPeriod;
}
export interface PaddlePlanChangeRequest {
    new_plan: 'monthly' | 'yearly';
}
/**
 * @deprecated Migrating to Paddle, but needed to allow existing customers to cancel their Stripe subscriptions
 */
export interface StripeCustomerPortalSessionRequest {
    return_url: string;
}
/**
 * @deprecated Migrating to Paddle, but needed to allow existing customers to cancel their Stripe subscriptions
 */
export interface StripeCustomerPortalSessionResponse {
    url: string;
}
export type UserValue = string | number | boolean | null | UserValue[];
export type UserKeyValues = {
    [key: string]: UserValue;
};
export type Sex = 'male' | 'female' | 'other';
/**
 * Used for the chat backend to validate authentication details
 */
export type UserAuthenticationValidationResponse = 'unauthorized' | 'authorized_user' | 'admin' | 'banned' | 'shadow_banned';
declare const _validUserWorkoutMetricsTypes: readonly ["duration", "reps"];
/**
 * Used for hevy-web for fetching profile metrics and calendar data
 */
export type UserWorkoutMetricsType = Lookup<typeof _validUserWorkoutMetricsTypes>;
export declare const isValidUserWorkoutMetricsType: (x: any) => x is UserWorkoutMetricsType;
interface WorkoutMetricBase {
    workout_id: string;
    start_time: number;
    type: UserWorkoutMetricsType;
}
export interface RepsWorkoutMetric extends WorkoutMetricBase {
    type: 'reps';
    reps: number;
}
export interface DurationWorkoutMetric extends WorkoutMetricBase {
    type: 'duration';
    duration_seconds: number;
}
export type WorkoutMetric = RepsWorkoutMetric | DurationWorkoutMetric;
export interface UserCalendarWorkout {
    workout_short_id: string;
    title: string;
    start_time: number;
    duration_seconds: number;
}
interface BaseClientActivity {
    type: string;
    date: string;
    client_id: string;
}
export interface ClientWorkoutActivity extends BaseClientActivity {
    type: 'workout';
    workout_name: string;
    workout_id: string;
    duration_seconds: number;
    total_volume_kg: number;
    set_count: number;
    prs: SetPersonalRecord[];
}
export interface ClientMeasurementActivity extends BaseClientActivity {
    type: 'measurement';
    measurement_id: number;
    measurement_types: string[];
}
export interface ClientBodyweightMeasurementActivity extends BaseClientActivity {
    type: 'bodyweight-measurement';
    measurement_id: number;
    weight_kg: number;
    trend_value: number;
}
export interface ClientInviteAcceptedActivity extends BaseClientActivity {
    type: 'invite-accepted';
}
export interface ClientAddedProgressPictureActivity extends BaseClientActivity {
    type: 'progress-picture';
    picture_url: string;
    measurement_id: number;
}
export type ClientActivity = ClientWorkoutActivity | ClientMeasurementActivity | ClientBodyweightMeasurementActivity | ClientInviteAcceptedActivity | ClientAddedProgressPictureActivity;
export interface WeeklyActiveClients {
    week_start_date: string;
    active_client_ids: string[];
    inactive_client_ids: string[];
}
interface UserWorkoutBaseMedia {
    workout_id: string;
    workout_name: string;
    workout_index: number;
}
export interface UserWorkoutImage extends UserWorkoutBaseMedia {
    type: 'image';
    url: string;
}
export interface UserWorkoutVideo extends UserWorkoutBaseMedia {
    type: 'video';
    url: string;
    thumbnail_url: string;
}
export type UserWorkoutMedia = UserWorkoutImage | UserWorkoutVideo;
export type RepInputType = 'reps' | 'rep-range';
export type ShareToPlatform = 'strava' | 'appleHealth' | 'healthConnect';
export type WorkoutVisibility = 'public' | 'private' | 'default';
export interface CreateRoutineCopyRequest {
    routineId: string;
    ignoreValues: boolean;
    index: number | null;
    copiedRoutineTitle?: string;
    folderId: number | null;
}
export type HevyPlatforms = 'hevy' | 'hevy-web' | 'hevy-coach' | 'hevy-coach-web';
export type FeedbackType = 'general' | 'feature-request' | 'bug-report' | 'get-help' | 'report-comment' | 'report-workout' | 'report-profile' | 'rating-review' | 'trainer-rating' | 'trainer-general' | 'gyms-general' | 'cancel-subscription';
interface BaseFeedback {
    platform: HevyPlatforms;
    type: FeedbackType;
    userId: string;
    message?: string;
    data?: any;
    debugInfo?: any;
}
export interface GeneralFeedback extends BaseFeedback {
    type: 'general';
}
export interface FeatureRequestFeedback extends BaseFeedback {
    type: 'feature-request';
}
export interface BugReportFeedback extends BaseFeedback {
    type: 'bug-report';
}
export interface GetHelpFeedback extends BaseFeedback {
    type: 'get-help';
    data: {
        source: string;
    };
}
export interface ReportCommentFeedback extends BaseFeedback {
    type: 'report-comment';
    data: {
        commentId: number;
        commentUsername: string;
        comment: string;
        workoutId: string;
    };
}
export interface ReportWorkoutFeedback extends BaseFeedback {
    type: 'report-workout';
    data: {
        workoutId: string;
        workoutUsername: string;
    };
}
export interface ReportProfileFeedback extends BaseFeedback {
    type: 'report-profile';
    data: {
        profileUsername: string;
    };
}
export interface RatingPromptFeedback extends BaseFeedback {
    type: 'rating-review';
}
export interface TrainerRatingPromptFeedback extends BaseFeedback {
    type: 'trainer-rating';
    data: {
        rating: number;
    };
}
export interface TrainerGeneralFeedback extends BaseFeedback {
    type: 'trainer-general';
}
export interface GymsGeneralFeedback extends BaseFeedback {
    type: 'gyms-general';
}
export interface CancelSubscriptionFeedback extends BaseFeedback {
    type: 'cancel-subscription';
    data?: {
        reason: string;
    };
}
export type Feedback = GeneralFeedback | FeatureRequestFeedback | BugReportFeedback | GetHelpFeedback | ReportCommentFeedback | ReportWorkoutFeedback | ReportProfileFeedback | RatingPromptFeedback | TrainerRatingPromptFeedback | TrainerGeneralFeedback | GymsGeneralFeedback | CancelSubscriptionFeedback;
export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | null;
export interface AppLogLine {
    /**
     * Line index, starts from 0 when app is initialised and increments by 1 for
     * each line logged by the log util.
     */
    index: number;
    /** Unix ms. String so it's simpler to handle across different platforms. */
    timestamp: string;
    logLevel: LogLevel;
    /** Used by android.util.Log on Wear OS */
    tag?: string;
    msg: string;
}
export interface PostAppLogRequest {
    version: 1;
    lines: AppLogLine[];
}
export interface BackofficeAppLogResponse {
    lines: AppLogLine[];
}
export interface BackofficeAppLogIndexResponse {
    username: string;
    entries: {
        id: string;
        timestamp: string;
        appPlatform: string | null;
        appVersion: string | null;
        appBuildNumber: string | null;
        linesLength: number;
        fileSizeBytes: number;
    }[];
}
declare const _suggestedUserSources: readonly ["popular", "local", "contact", "mutual_follows", "follows_you", "featured", "hyper_local", "top_discovery"];
export type SuggestedUserSource = Lookup<typeof _suggestedUserSources>;
export declare const isSuggestedUserSource: (source: string) => source is SuggestedUserSource;
export type SuggestedUserLabel = 'contact' | 'mutual_friends' | 'follows_you' | 'featured';
export interface SuggestedUser {
    id: string;
    profile_pic?: string;
    username: string;
    full_name?: string;
    following_status: FollowingStatus;
    private_profile: boolean;
    verified: boolean;
    source?: SuggestedUserSource;
    label: SuggestedUserLabel;
}
export type FollowRate = {
    source: SuggestedUserSource;
    follows: number;
    total: number;
};
export interface BackofficeSuggestedUsersFollowRateResponse {
    follow_rates: FollowRate[];
}
export type BackofficeFeedback = {
    user_id: string;
    platform: string;
    type: string;
    username?: string;
    message?: string;
    data?: any;
    debug_info?: any;
    created_at: Date;
};
export interface BackofficeFeedbacksResponse {
    feedbacks: BackofficeFeedback[];
}
export interface FormatAtText {
    format: 'none' | '@' | 'link';
    text: string;
}
export interface GoogleWebSignInRequest {
    code: string;
    gympassUserId?: string;
}
export interface GoogleCoachWebSignInRequest {
    code: string;
    invite_short_id?: string;
}
export interface UserPushNotificationSettings {
    comment_discussion: boolean;
    comment_likes: boolean;
    comment_mention: boolean;
    comment_on_workout: boolean;
    comment_replies: boolean;
    follows: boolean;
    likes: boolean;
    monthly_report: boolean;
}
export interface UserPushNotificationSettingsUpdate {
    comment_discussion?: boolean;
    comment_likes?: boolean;
    comment_mention?: boolean;
    comment_on_workout?: boolean;
    comment_replies?: boolean;
    follows?: boolean;
    likes?: boolean;
    monthly_report?: boolean;
}
export interface AvailableEquipment {
    platesKg: number[];
    platesLbs: number[];
    barsKg: number[];
    barsLbs: number[];
    dumbbellsKg: number[];
    dumbbellsLbs: number[];
}
export interface TrainerUserPreferences {
    excludedExercisesIds: string[];
    availableEquipment: AvailableEquipment;
}
export interface LinkPreviewMetadataResponse {
    title: string;
    url: string;
    image_url: string;
    twitter_image_url: string;
}
export interface UserLinkPreviewMetadataResponse extends LinkPreviewMetadataResponse {
    username: string;
}
export interface RoutineLinkPreviewMetadataResponse extends LinkPreviewMetadataResponse {
    username: string;
    exercise_count: number;
}
export interface FolderLinkPreviewMetadataResponse extends LinkPreviewMetadataResponse {
    username: string;
    routine_count: number;
}
export interface ExerciseHistorySet {
    weight_kg: number | null;
    reps: number | null;
    indicator: SetType;
    duration_seconds: number | null;
    distance_meters: number | null;
    rpe: number | null;
    custom_metric: number | null;
    set_index: number;
    prs: SetPersonalRecordType[];
}
export interface ExerciseInstructionsStep {
    index?: number;
    description: string;
}
export interface ExerciseHistoryWorkout {
    id: string;
    name: string;
    start_time: number;
    exercises: {
        sets: ExerciseHistorySet[];
    }[];
}
export declare const supportedScopes: readonly ["read-workout", "modify-workout", "read-routine", "modify-routine", "unrestricted"];
export type OAuthScope = Lookup<typeof supportedScopes>;
export declare const isOAuthScope: (x: string) => x is OAuthScope;
export type WorkoutMediaBackoffice = WorkoutMedia & {
    deleted: boolean;
    notes?: string;
};
export interface WorkoutsWithMediaBackofficeResponse {
    username: string;
    workouts: {
        id: string;
        name: string;
        media: WorkoutMediaBackoffice[];
    }[];
}
export interface GetAccountsByEmailResponse {
    users: {
        id: string;
        username: string;
        profile_pic: string | null;
        email: string;
        wellhub_email: string | null;
    }[];
}
export type PostEmailBackofficeRequest = z.infer<typeof postEmailBackofficeSchema>;
export type BugReportQuestion = z.infer<typeof BugReportQuestionSchema>;
export type CreateBugReportRequestBody = z.infer<typeof CreateBugReportRequestBodySchema>;
export interface UserReportSummaryBackoffice {
    reported_by: string;
    reported_at: string;
    report_type: string | null;
    reason: string;
    data: unknown;
}
export interface GetReportedUserSummaryBackofficeResponse {
    username: string;
    user_reports: UserReportSummaryBackoffice[];
}
export type PutTrainerWorkoutTemplateIndicesRequest = z.infer<typeof putTrainerWorkoutTemplateIndicesSchema>;