import { AltSportsData } from 'altsportsdata';

const client = new AltSportsData({
  apiKey: process.env.ALTSPORTSDATA_API_KEY
});

// List leagues
const leagues = await client.leagues.list({
  sportType: 'Soccer',
  tier: 'elite'
});

// Get specific league
const league = await client.leagues.get('league_001');

// Check readiness score
const readiness = await client.leagues.readiness('league_001');

from altsportsdata import AltSportsData
import os

client = AltSportsData(
    api_key=os.getenv('ALTSPORTSDATA_API_KEY')
)

# List leagues
leagues = client.leagues.list(
    sport_type='Soccer',
    tier='elite'
)

# Get specific league
league = client.leagues.get('league_001')

# Check readiness score
readiness = client.leagues.readiness('league_001')

// TypeScript autocomplete and type checking
const leagues: ListLeaguesResponse = await client.leagues.list({
  sportType: 'Soccer', // IDE autocomplete available
  tier: 'elite'        // Type-checked values
});

// Strongly typed responses
leagues.data.forEach((league: League) => {
  console.log(league.name); // Type-safe property access
});

# Python type hints
from altsportsdata.types import League, ListLeaguesResponse

leagues: ListLeaguesResponse = client.leagues.list(
    sport_type='Soccer',
    tier='elite'
)

# Type-safe iteration
league: League
for league in leagues.data:
    print(league.name)  # Type-checked attributes

import { 
  ResourceNotFoundError, 
  RateLimitError,
  ValidationError 
} from 'altsportsdata';

try {
  const league = await client.leagues.get('invalid_id');
} catch (error) {
  if (error instanceof ResourceNotFoundError) {
    console.error('League not found');
  } else if (error instanceof RateLimitError) {
    console.error('Rate limit exceeded');
    console.log(`Retry after: ${error.retryAfter}`);
  } else if (error instanceof ValidationError) {
    console.error('Invalid parameters:', error.details);
  }
}

from altsportsdata.exceptions import (
    ResourceNotFoundError,
    RateLimitError,
    ValidationError
)

try:
    league = client.leagues.get('invalid_id')
except ResourceNotFoundError:
    print('League not found')
except RateLimitError as e:
    print(f'Rate limit exceeded')
    print(f'Retry after: {e.retry_after}')
except ValidationError as e:
    print(f'Invalid parameters: {e.details}')

// Manual pagination
let offset = 0;
const limit = 100;

while (true) {
  const response = await client.leagues.list({ limit, offset });
  
  // Process leagues
  response.data.forEach(league => {
    console.log(league.name);
  });

  if (!response.meta.has_more) break;
  offset += limit;
}

// Auto-pagination iterator
for await (const league of client.leagues.listAll({ tier: 'elite' })) {
  console.log(league.name);
}

# Manual pagination
offset = 0
limit = 100

while True:
    response = client.leagues.list(limit=limit, offset=offset)
    
    # Process leagues
    for league in response.data:
        print(league.name)

    if not response.meta.has_more:
        break
    offset += limit

# Auto-pagination iterator
for league in client.leagues.list_all(tier='elite'):
    print(league.name)

const client = new AltSportsData({
  apiKey: 'your-api-key',
  retry: {
    enabled: true,
    maxRetries: 3,
    initialDelay: 1000,
    maxDelay: 10000
  }
});

client = AltSportsData(
    api_key='your-api-key',
    retry_config={
        'enabled': True,
        'max_retries': 3,
        'initial_delay': 1.0,
        'max_delay': 10.0
    }
)