curl -X GET "https://api.tktchurch.com/v1/auth/linked-providers" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..."

const getLinkedProviders = async (accessToken) => {
  const response = await fetch(
    'https://api.tktchurch.com/v1/auth/linked-providers',
    {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error.reason);
  }

  return response.json();
};

// Usage
try {
  const providers = await getLinkedProviders('eyJhbGciOiJIUzI1NiIs...');
  console.log('Primary provider:', providers.primaryProvider);
  console.log('Linked providers:', providers.linkedProviders);
} catch (error) {
  console.error('Failed to get linked providers:', error.message);
}

struct LinkedProvider: Codable {
    let provider: String
    let providerId: String
    let email: String?
    let displayName: String?
    let photoUrl: String?
}

struct LinkedProvidersResponse: Codable {
    let primaryProvider: String
    let linkedProviders: [LinkedProvider]
}

func getLinkedProviders(accessToken: String) async throws -> LinkedProvidersResponse {
    var urlRequest = URLRequest(url: URL(string: "https://api.tktchurch.com/v1/auth/linked-providers")!)
    urlRequest.httpMethod = "GET"
    urlRequest.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
    
    let (data, response) = try await URLSession.shared.data(for: urlRequest)
    guard let httpResponse = response as? HTTPURLResponse else {
        throw URLError(.badServerResponse)
    }
    
    if httpResponse.statusCode != 200 {
        let error = try JSONDecoder().decode(ErrorResponse.self, from: data)
        throw error
    }
    
    return try JSONDecoder().decode(LinkedProvidersResponse.self, from: data)
}

// Usage
do {
    let providers = try await getLinkedProviders(accessToken: "eyJhbGciOiJIUzI1NiIs...")
    print("Primary provider:", providers.primaryProvider)
    print("Linked providers:", providers.linkedProviders)
} catch {
    print("Failed to get linked providers: \(error.localizedDescription)")
}

data class LinkedProvider(
    val provider: String,
    val providerId: String,
    val email: String?,
    val displayName: String?,
    val photoUrl: String?
)

data class LinkedProvidersResponse(
    val primaryProvider: String,
    val linkedProviders: List<LinkedProvider>
)

class UserService(private val client: OkHttpClient) {
    suspend fun getLinkedProviders(accessToken: String): LinkedProvidersResponse {
        val request = Request.Builder()
            .url("https://api.tktchurch.com/v1/auth/linked-providers")
            .get()
            .header("Authorization", "Bearer $accessToken")
            .build()

        client.newCall(request).execute().use { response ->
            if (!response.isSuccessful) {
                val error = response.body?.string()?.fromJson<ErrorResponse>()
                throw Exception(error?.reason ?: "Failed to get linked providers")
            }
            
            return response.body?.string()?.fromJson<LinkedProvidersResponse>()
                ?: throw Exception("Empty response")
        }
    }
}

// Usage
try {
    val providers = userService.getLinkedProviders("eyJhbGciOiJIUzI1NiIs...")
    println("Primary provider: ${providers.primaryProvider}")
    println("Linked providers: ${providers.linkedProviders}")
} catch (e: Exception) {
    println("Failed to get linked providers: ${e.message}")
}

import axios from 'axios';

interface LinkedProvider {
  provider: 'google' | 'facebook' | 'apple';
  providerId: string;
  email?: string;
  displayName?: string;
  photoUrl?: string;
}

interface LinkedProvidersResponse {
  primaryProvider: 'local' | 'google' | 'facebook' | 'apple';
  linkedProviders: LinkedProvider[];
}

const getLinkedProviders = async (accessToken: string): Promise<LinkedProvidersResponse> => {
  try {
    const response = await axios.get(
      'https://api.tktchurch.com/v1/auth/linked-providers',
      {
        headers: {
          'Authorization': `Bearer ${accessToken}`
        },
      }
    );
    
    return response.data;
  } catch (error) {
    if (axios.isAxiosError(error)) {
      throw new Error(error.response?.data?.error?.reason || 'Failed to get linked providers');
    }
    throw error;
  }
};

// Usage
try {
  const providers = await getLinkedProviders('eyJhbGciOiJIUzI1NiIs...');
  console.log('Primary provider:', providers.primaryProvider);
  console.log('Linked providers:', providers.linkedProviders);
} catch (error) {
  console.error('Failed to get linked providers:', error.message);
}

{
  "primaryProvider": "local",
  "linkedProviders": [
    {
      "provider": "google",
      "providerId": "12345",
      "email": "[email protected]",
      "displayName": "John Doe",
      "photoUrl": "https://example.com/photo.jpg"
    },
    {
      "provider": "apple",
      "providerId": "67890",
      "email": "[email protected]",
      "displayName": "John Doe"
    }
  ]
}

{
  "error": {
    "status": 401,
    "reason": "Invalid or expired access token"
  }
}