go baby go

go-garth/garth/client/auth.go

@@ -0,0 +1,37 @@
+package client
+
+import (
+	"time"
+)
+
+// OAuth1Token represents OAuth 1.0a credentials
+type OAuth1Token struct {
+	Token       string
+	TokenSecret string
+	CreatedAt   time.Time
+}
+
+// Expired checks if token is expired (OAuth1 tokens typically don't expire but we'll implement for consistency)
+func (t *OAuth1Token) Expired() bool {
+	return false // OAuth1 tokens don't typically expire
+}
+
+// OAuth2Token represents OAuth 2.0 credentials
+type OAuth2Token struct {
+	AccessToken  string
+	RefreshToken string
+	TokenType    string
+	ExpiresIn    int
+	ExpiresAt    time.Time
+}
+
+// Expired checks if token is expired
+func (t *OAuth2Token) Expired() bool {
+	return time.Now().After(t.ExpiresAt)
+}
+
+// RefreshIfNeeded refreshes token if expired (implementation pending)
+func (t *OAuth2Token) RefreshIfNeeded(client *Client) error {
+	// Placeholder for token refresh logic
+	return nil
+}

go-garth/garth/client/auth_test.go

@@ -0,0 +1,57 @@
+package client_test
+
+import (
+	"net/http"
+	"testing"
+
+	"garmin-connect/garth/testutils"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"garmin-connect/garth/client"
+	"garmin-connect/garth/errors"
+)
+
+func TestClient_Login_Success(t *testing.T) {
+	// Create mock SSO server
+	ssoServer := testutils.MockJSONResponse(http.StatusOK, `{
+		"access_token": "test_token",
+		"token_type": "Bearer",
+		"expires_in": 3600
+	}`)
+	defer ssoServer.Close()
+
+	// Create client with test configuration
+	c, err := client.NewClient("example.com")
+	require.NoError(t, err)
+	c.Domain = ssoServer.URL
+
+	// Perform login
+	err = c.Login("test@example.com", "password")
+
+	// Verify login
+	require.NoError(t, err)
+	assert.Equal(t, "Bearer test_token", c.AuthToken)
+}
+
+func TestClient_Login_Failure(t *testing.T) {
+	// Create mock SSO server returning error
+	ssoServer := testutils.MockJSONResponse(http.StatusUnauthorized, `{
+		"error": "invalid_credentials"
+	}`)
+	defer ssoServer.Close()
+
+	// Create client with test configuration
+	c, err := client.NewClient("example.com")
+	require.NoError(t, err)
+	c.Domain = ssoServer.URL
+
+	// Perform login
+	err = c.Login("test@example.com", "wrongpassword")
+
+	// Verify error
+	require.Error(t, err)
+	assert.IsType(t, &errors.AuthenticationError{}, err)
+	assert.Contains(t, err.Error(), "SSO login failed")
+}

go-garth/garth/client/client.go

@@ -0,0 +1,281 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"time"
+
+	"garmin-connect/garth/errors"
+	"garmin-connect/garth/sso"
+	"garmin-connect/garth/types"
+)
+
+// Client represents the Garmin Connect API client
+type Client struct {
+	Domain      string
+	HTTPClient  *http.Client
+	Username    string
+	AuthToken   string
+	OAuth1Token *types.OAuth1Token
+	OAuth2Token *types.OAuth2Token
+}
+
+// NewClient creates a new Garmin Connect client
+func NewClient(domain string) (*Client, error) {
+	if domain == "" {
+		domain = "garmin.com"
+	}
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to create cookie jar",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &Client{
+		Domain: domain,
+		HTTPClient: &http.Client{
+			Jar:     jar,
+			Timeout: 30 * time.Second,
+			CheckRedirect: func(req *http.Request, via []*http.Request) error {
+				if len(via) >= 10 {
+					return &errors.APIError{
+						GarthHTTPError: errors.GarthHTTPError{
+							GarthError: errors.GarthError{
+								Message: "Too many redirects",
+							},
+						},
+					}
+				}
+				return nil
+			},
+		},
+	}, nil
+}
+
+// Login authenticates to Garmin Connect using SSO
+func (c *Client) Login(email, password string) error {
+	ssoClient := sso.NewClient(c.Domain)
+	oauth2Token, mfaContext, err := ssoClient.Login(email, password)
+	if err != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "SSO login failed",
+				Cause:   err,
+			},
+		}
+	}
+
+	// Handle MFA required
+	if mfaContext != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "MFA required - not implemented yet",
+			},
+		}
+	}
+
+	c.OAuth2Token = oauth2Token
+	c.AuthToken = fmt.Sprintf("%s %s", oauth2Token.TokenType, oauth2Token.AccessToken)
+
+	// Get user profile to set username
+	profile, err := c.GetUserProfile()
+	if err != nil {
+		return &errors.AuthenticationError{
+			GarthError: errors.GarthError{
+				Message: "Failed to get user profile after login",
+				Cause:   err,
+			},
+		}
+	}
+	c.Username = profile.UserName
+
+	return nil
+}
+
+// GetUserProfile retrieves the current user's full profile
+func (c *Client) GetUserProfile() (*UserProfile, error) {
+	profileURL := fmt.Sprintf("https://connectapi.%s/userprofile-service/socialProfile", c.Domain)
+
+	req, err := http.NewRequest("GET", profileURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create profile request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get user profile",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "Profile request failed",
+				},
+			},
+		}
+	}
+
+	var profile UserProfile
+	if err := json.NewDecoder(resp.Body).Decode(&profile); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse profile",
+				Cause:   err,
+			},
+		}
+	}
+
+	return &profile, nil
+}
+
+// GetActivities retrieves recent activities
+func (c *Client) GetActivities(limit int) ([]types.Activity, error) {
+	if limit <= 0 {
+		limit = 10
+	}
+
+	activitiesURL := fmt.Sprintf("https://connectapi.%s/activitylist-service/activities/search/activities?limit=%d&start=0", c.Domain, limit)
+
+	req, err := http.NewRequest("GET", activitiesURL, nil)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to create activities request",
+					Cause:   err,
+				},
+			},
+		}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{
+					Message: "Failed to get activities",
+					Cause:   err,
+				},
+			},
+		}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{
+			GarthHTTPError: errors.GarthHTTPError{
+				StatusCode: resp.StatusCode,
+				Response:   string(body),
+				GarthError: errors.GarthError{
+					Message: "Activities request failed",
+				},
+			},
+		}
+	}
+
+	var activities []types.Activity
+	if err := json.NewDecoder(resp.Body).Decode(&activities); err != nil {
+		return nil, &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to parse activities",
+				Cause:   err,
+			},
+		}
+	}
+
+	return activities, nil
+}
+
+// SaveSession saves the current session to a file
+func (c *Client) SaveSession(filename string) error {
+	session := types.SessionData{
+		Domain:    c.Domain,
+		Username:  c.Username,
+		AuthToken: c.AuthToken,
+	}
+
+	data, err := json.MarshalIndent(session, "", "  ")
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to marshal session",
+				Cause:   err,
+			},
+		}
+	}
+
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to write session file",
+				Cause:   err,
+			},
+		}
+	}
+
+	return nil
+}
+
+// LoadSession loads a session from a file
+func (c *Client) LoadSession(filename string) error {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to read session file",
+				Cause:   err,
+			},
+		}
+	}
+
+	var session types.SessionData
+	if err := json.Unmarshal(data, &session); err != nil {
+		return &errors.IOError{
+			GarthError: errors.GarthError{
+				Message: "Failed to unmarshal session",
+				Cause:   err,
+			},
+		}
+	}
+
+	c.Domain = session.Domain
+	c.Username = session.Username
+	c.AuthToken = session.AuthToken
+
+	return nil
+}

go-garth/garth/client/client_test.go

@@ -0,0 +1,40 @@
+package client_test
+
+import (
+	"net/http"
+	"testing"
+	"time"
+
+	"garmin-connect/garth/testutils"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"garmin-connect/garth/client"
+)
+
+func TestClient_GetUserProfile(t *testing.T) {
+	// Create mock server returning user profile
+	server := testutils.MockJSONResponse(http.StatusOK, `{
+		"userName": "testuser",
+		"displayName": "Test User",
+		"fullName": "Test User",
+		"location": "Test Location"
+	}`)
+	defer server.Close()
+
+	// Create client with test configuration
+	c := &client.Client{
+		Domain:     server.URL,
+		HTTPClient: &http.Client{Timeout: 5 * time.Second},
+		AuthToken:  "Bearer testtoken",
+	}
+
+	// Get user profile
+	profile, err := c.GetUserProfile()
+
+	// Verify response
+	require.NoError(t, err)
+	assert.Equal(t, "testuser", profile.UserName)
+	assert.Equal(t, "Test User", profile.DisplayName)
+}

go-garth/garth/client/http.go

@@ -0,0 +1,130 @@
+package client
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"garmin-connect/garth/errors"
+)
+
+func (c *Client) ConnectAPI(path, method string, data interface{}) (interface{}, error) {
+	url := fmt.Sprintf("https://connectapi.%s%s", c.Domain, path)
+
+	var body io.Reader
+	if data != nil && (method == "POST" || method == "PUT") {
+		jsonData, err := json.Marshal(data)
+		if err != nil {
+			return nil, &errors.APIError{GarthHTTPError: errors.GarthHTTPError{
+				GarthError: errors.GarthError{Message: "Failed to marshal request data", Cause: err}}}
+		}
+		body = bytes.NewReader(jsonData)
+	}
+
+	req, err := http.NewRequest(method, url, body)
+	if err != nil {
+		return nil, &errors.APIError{GarthHTTPError: errors.GarthHTTPError{
+			GarthError: errors.GarthError{Message: "Failed to create request", Cause: err}}}
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "GCM-iOS-5.7.2.1")
+	if body != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, &errors.APIError{GarthHTTPError: errors.GarthHTTPError{
+			GarthError: errors.GarthError{Message: "API request failed", Cause: err}}}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 204 {
+		return nil, nil
+	}
+
+	if resp.StatusCode >= 400 {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return nil, &errors.APIError{GarthHTTPError: errors.GarthHTTPError{
+			StatusCode: resp.StatusCode,
+			Response:   string(bodyBytes),
+			GarthError: errors.GarthError{Message: "API error"}}}
+	}
+
+	var result interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, &errors.IOError{GarthError: errors.GarthError{
+			Message: "Failed to parse response", Cause: err}}
+	}
+
+	return result, nil
+}
+
+func (c *Client) Download(path string) ([]byte, error) {
+	url := fmt.Sprintf("https://connectapi.%s%s", c.Domain, path)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "GCM-iOS-5.7.2.1")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	return io.ReadAll(resp.Body)
+}
+
+func (c *Client) Upload(filePath, uploadPath string) (map[string]interface{}, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, &errors.IOError{GarthError: errors.GarthError{
+			Message: "Failed to open file", Cause: err}}
+	}
+	defer file.Close()
+
+	var b bytes.Buffer
+	writer := multipart.NewWriter(&b)
+	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = io.Copy(part, file)
+	if err != nil {
+		return nil, err
+	}
+	writer.Close()
+
+	url := fmt.Sprintf("https://connectapi.%s%s", c.Domain, uploadPath)
+	req, err := http.NewRequest("POST", url, &b)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var result map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

go-garth/garth/client/profile.go

@@ -0,0 +1,71 @@
+package client
+
+import (
+	"time"
+)
+
+type UserProfile struct {
+	ID                            int       `json:"id"`
+	ProfileID                     int       `json:"profileId"`
+	GarminGUID                    string    `json:"garminGuid"`
+	DisplayName                   string    `json:"displayName"`
+	FullName                      string    `json:"fullName"`
+	UserName                      string    `json:"userName"`
+	ProfileImageType              *string   `json:"profileImageType"`
+	ProfileImageURLLarge          *string   `json:"profileImageUrlLarge"`
+	ProfileImageURLMedium         *string   `json:"profileImageUrlMedium"`
+	ProfileImageURLSmall          *string   `json:"profileImageUrlSmall"`
+	Location                      *string   `json:"location"`
+	FacebookURL                   *string   `json:"facebookUrl"`
+	TwitterURL                    *string   `json:"twitterUrl"`
+	PersonalWebsite               *string   `json:"personalWebsite"`
+	Motivation                    *string   `json:"motivation"`
+	Bio                           *string   `json:"bio"`
+	PrimaryActivity               *string   `json:"primaryActivity"`
+	FavoriteActivityTypes         []string  `json:"favoriteActivityTypes"`
+	RunningTrainingSpeed          float64   `json:"runningTrainingSpeed"`
+	CyclingTrainingSpeed          float64   `json:"cyclingTrainingSpeed"`
+	FavoriteCyclingActivityTypes  []string  `json:"favoriteCyclingActivityTypes"`
+	CyclingClassification         *string   `json:"cyclingClassification"`
+	CyclingMaxAvgPower            float64   `json:"cyclingMaxAvgPower"`
+	SwimmingTrainingSpeed         float64   `json:"swimmingTrainingSpeed"`
+	ProfileVisibility             string    `json:"profileVisibility"`
+	ActivityStartVisibility       string    `json:"activityStartVisibility"`
+	ActivityMapVisibility         string    `json:"activityMapVisibility"`
+	CourseVisibility              string    `json:"courseVisibility"`
+	ActivityHeartRateVisibility   string    `json:"activityHeartRateVisibility"`
+	ActivityPowerVisibility       string    `json:"activityPowerVisibility"`
+	BadgeVisibility               string    `json:"badgeVisibility"`
+	ShowAge                       bool      `json:"showAge"`
+	ShowWeight                    bool      `json:"showWeight"`
+	ShowHeight                    bool      `json:"showHeight"`
+	ShowWeightClass               bool      `json:"showWeightClass"`
+	ShowAgeRange                  bool      `json:"showAgeRange"`
+	ShowGender                    bool      `json:"showGender"`
+	ShowActivityClass             bool      `json:"showActivityClass"`
+	ShowVO2Max                    bool      `json:"showVo2Max"`
+	ShowPersonalRecords           bool      `json:"showPersonalRecords"`
+	ShowLast12Months              bool      `json:"showLast12Months"`
+	ShowLifetimeTotals            bool      `json:"showLifetimeTotals"`
+	ShowUpcomingEvents            bool      `json:"showUpcomingEvents"`
+	ShowRecentFavorites           bool      `json:"showRecentFavorites"`
+	ShowRecentDevice              bool      `json:"showRecentDevice"`
+	ShowRecentGear                bool      `json:"showRecentGear"`
+	ShowBadges                    bool      `json:"showBadges"`
+	OtherActivity                 *string   `json:"otherActivity"`
+	OtherPrimaryActivity          *string   `json:"otherPrimaryActivity"`
+	OtherMotivation               *string   `json:"otherMotivation"`
+	UserRoles                     []string  `json:"userRoles"`
+	NameApproved                  bool      `json:"nameApproved"`
+	UserProfileFullName           string    `json:"userProfileFullName"`
+	MakeGolfScorecardsPrivate     bool      `json:"makeGolfScorecardsPrivate"`
+	AllowGolfLiveScoring          bool      `json:"allowGolfLiveScoring"`
+	AllowGolfScoringByConnections bool      `json:"allowGolfScoringByConnections"`
+	UserLevel                     int       `json:"userLevel"`
+	UserPoint                     int       `json:"userPoint"`
+	LevelUpdateDate               time.Time `json:"levelUpdateDate"`
+	LevelIsViewed                 bool      `json:"levelIsViewed"`
+	LevelPointThreshold           int       `json:"levelPointThreshold"`
+	UserPointOffset               int       `json:"userPointOffset"`
+	UserPro                       bool      `json:"userPro"`
+}

go-garth/garth/client/settings.go

@@ -0,0 +1,122 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+type PowerFormat struct {
+	FormatID      int     `json:"formatId"`
+	FormatKey     string  `json:"formatKey"`
+	MinFraction   int     `json:"minFraction"`
+	MaxFraction   int     `json:"maxFraction"`
+	GroupingUsed  bool    `json:"groupingUsed"`
+	DisplayFormat *string `json:"displayFormat"`
+}
+
+type FirstDayOfWeek struct {
+	DayID              int    `json:"dayId"`
+	DayName            string `json:"dayName"`
+	SortOrder          int    `json:"sortOrder"`
+	IsPossibleFirstDay bool   `json:"isPossibleFirstDay"`
+}
+
+type WeatherLocation struct {
+	UseFixedLocation *bool    `json:"useFixedLocation"`
+	Latitude         *float64 `json:"latitude"`
+	Longitude        *float64 `json:"longitude"`
+	LocationName     *string  `json:"locationName"`
+	ISOCountryCode   *string  `json:"isoCountryCode"`
+	PostalCode       *string  `json:"postalCode"`
+}
+
+type UserData struct {
+	Gender                         string                   `json:"gender"`
+	Weight                         float64                  `json:"weight"`
+	Height                         float64                  `json:"height"`
+	TimeFormat                     string                   `json:"timeFormat"`
+	BirthDate                      time.Time                `json:"birthDate"`
+	MeasurementSystem              string                   `json:"measurementSystem"`
+	ActivityLevel                  *string                  `json:"activityLevel"`
+	Handedness                     string                   `json:"handedness"`
+	PowerFormat                    PowerFormat              `json:"powerFormat"`
+	HeartRateFormat                PowerFormat              `json:"heartRateFormat"`
+	FirstDayOfWeek                 FirstDayOfWeek           `json:"firstDayOfWeek"`
+	VO2MaxRunning                  *float64                 `json:"vo2MaxRunning"`
+	VO2MaxCycling                  *float64                 `json:"vo2MaxCycling"`
+	LactateThresholdSpeed          *float64                 `json:"lactateThresholdSpeed"`
+	LactateThresholdHeartRate      *float64                 `json:"lactateThresholdHeartRate"`
+	DiveNumber                     *int                     `json:"diveNumber"`
+	IntensityMinutesCalcMethod     string                   `json:"intensityMinutesCalcMethod"`
+	ModerateIntensityMinutesHRZone int                      `json:"moderateIntensityMinutesHrZone"`
+	VigorousIntensityMinutesHRZone int                      `json:"vigorousIntensityMinutesHrZone"`
+	HydrationMeasurementUnit       string                   `json:"hydrationMeasurementUnit"`
+	HydrationContainers            []map[string]interface{} `json:"hydrationContainers"`
+	HydrationAutoGoalEnabled       bool                     `json:"hydrationAutoGoalEnabled"`
+	FirstbeatMaxStressScore        *float64                 `json:"firstbeatMaxStressScore"`
+	FirstbeatCyclingLTTimestamp    *int64                   `json:"firstbeatCyclingLtTimestamp"`
+	FirstbeatRunningLTTimestamp    *int64                   `json:"firstbeatRunningLtTimestamp"`
+	ThresholdHeartRateAutoDetected bool                     `json:"thresholdHeartRateAutoDetected"`
+	FTPAutoDetected                *bool                    `json:"ftpAutoDetected"`
+	TrainingStatusPausedDate       *string                  `json:"trainingStatusPausedDate"`
+	WeatherLocation                *WeatherLocation         `json:"weatherLocation"`
+	GolfDistanceUnit               *string                  `json:"golfDistanceUnit"`
+	GolfElevationUnit              *string                  `json:"golfElevationUnit"`
+	GolfSpeedUnit                  *string                  `json:"golfSpeedUnit"`
+	ExternalBottomTime             *float64                 `json:"externalBottomTime"`
+}
+
+type UserSleep struct {
+	SleepTime        int  `json:"sleepTime"`
+	DefaultSleepTime bool `json:"defaultSleepTime"`
+	WakeTime         int  `json:"wakeTime"`
+	DefaultWakeTime  bool `json:"defaultWakeTime"`
+}
+
+type UserSleepWindow struct {
+	SleepWindowFrequency              string `json:"sleepWindowFrequency"`
+	StartSleepTimeSecondsFromMidnight int    `json:"startSleepTimeSecondsFromMidnight"`
+	EndSleepTimeSecondsFromMidnight   int    `json:"endSleepTimeSecondsFromMidnight"`
+}
+
+type UserSettings struct {
+	ID               int               `json:"id"`
+	UserData         UserData          `json:"userData"`
+	UserSleep        UserSleep         `json:"userSleep"`
+	ConnectDate      *string           `json:"connectDate"`
+	SourceType       *string           `json:"sourceType"`
+	UserSleepWindows []UserSleepWindow `json:"userSleepWindows,omitempty"`
+}
+
+func (c *Client) GetUserSettings() (*UserSettings, error) {
+	settingsURL := fmt.Sprintf("https://connectapi.%s/userprofile-service/userprofile/user-settings", c.Domain)
+
+	req, err := http.NewRequest("GET", settingsURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create settings request: %w", err)
+	}
+
+	req.Header.Set("Authorization", c.AuthToken)
+	req.Header.Set("User-Agent", "com.garmin.android.apps.connectmobile")
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get user settings: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("settings request failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var settings UserSettings
+	if err := json.NewDecoder(resp.Body).Decode(&settings); err != nil {
+		return nil, fmt.Errorf("failed to parse settings: %w", err)
+	}
+
+	return &settings, nil
+}