# Data Models

Reference for the data structures returned by the Content API.

**WorkoutModel:**
| Field | Type | Description |
|-------|------|-------------|
| id | String | Unique identifier |
| title | String | Workout name |
| category | String | Fitness or Rehabilitation |
| calories | Int? | Estimated calories burned |
| totalMinutes | Int? | Total duration in minutes |
| bodyParts | [String] | Targeted body parts |
| difficultyLevel | String? | Difficulty level |
| description | String | Workout description |
| imgURL | String | Workout thumbnail image |
| sequence | [ExerciseModel] | List of exercises |

**ExerciseModel:**
| Field | Type | Description |
|-------|------|-------------|
| id | String | Unique identifier |
| title | String | Exercise name |
| bodyParts | [String] | Targeted body parts |
| videoURL | String | Demo video URL |
| thumbnailURL | String | Thumbnail image URL |
| modelId | String | Motion tracking model ID (use in Camera Component) |
| description | String | Exercise description |
| steps | [String] | Step-by-step instructions |
| commonMistakes | String | Common mistakes to avoid |
| tips | String | Tips for proper form |

**PlanModel:**
| Field | Type | Description |
|-------|------|-------------|
| id | String | Unique identifier |
| title | String | Plan name |
| imgURL | String | Plan thumbnail image |
| category | PlanModelCategory | Category with description and levels |
| levels | [String: PlanLevel] | Dictionary of levels (1, 2, 3, etc.) |
| createdBy | String | Creator identifier |

**PlanLevel:**
| Field | Type | Description |
|-------|------|-------------|
| title | String | Level title |
| description | String | Level description |
| days | [String: PlanDay] | Dictionary of days |

**PlanDay:**
| Field | Type | Description |
|-------|------|-------------|
| title | String | Day title |
| description | String | Day description |
| workouts | [WorkoutSummary]? | List of workouts for this day |

**Working with Models**

_Swift (iOS)_
```swift
// Accessing workout model properties
Task {
    let result = await kinestex.fetchWorkout(id: "9zE1kzOzpU5d5dAJrPOY")

    switch result {
    case .success(let workout):
        // Basic properties
        print("Title: \(workout.title)")
        print("Category: \(workout.category ?? "N/A")")
        print("Duration: \(workout.totalMinutes ?? 0) minutes")
        print("Calories: \(workout.totalCalories ?? 0)")
        print("Difficulty: \(workout.difficultyLevel ?? "N/A")")

        // Body parts
        print("Targets: \(workout.bodyParts.joined(separator: ", "))")

        // Exercise sequence
        print("\nExercises (\(workout.sequence.count)):")
        for (index, exercise) in workout.sequence.enumerated() {
            print("\(index + 1). \(exercise.title)")
            print("   Model ID: \(exercise.modelId)")  // Use for Camera Component
            print("   Reps: \(exercise.workoutReps ?? exercise.averageReps ?? 0)")
        }

        // Access raw JSON if needed
        if let rawJSON = workout.rawJSON {
            print("\nRaw JSON available: \(rawJSON.keys.count) keys")
        }

    case .failure(let error):
        print("Error: \(error.localizedDescription)")
    }
}

// Working with plan structure
Task {
    let result = await kinestex.fetchPlan(id: "22B3qRU2r75hVXHgGiGx")

    switch result {
    case .success(let plan):
        print("Plan: \(plan.title)")
        print("Category: \(plan.category.description)")

        // Iterate through levels
        for (levelKey, level) in plan.levels {
            print("\nLevel \(levelKey): \(level.title)")

            // Iterate through days
            for (dayKey, day) in level.days {
                print("  Day \(dayKey): \(day.title)")

                // List workouts for this day
                if let workouts = day.workouts {
                    for workout in workouts {
                        print("    - \(workout.title) (\(workout.totalMinutes) min)")
                    }
                }
            }
        }

    case .failure(let error):
        print("Error: \(error.localizedDescription)")
    }
}
```

_Kotlin (Android)_
```kotlin
// Accessing workout model properties
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) {
        KinesteXSDK.api.fetchAPIContentData(
            contentType = ContentType.WORKOUT,
            id = "9zE1kzOzpU5d5dAJrPOY"
        )
    }

    when (result) {
        is APIContentResult.Workout -> {
            val workout = result.workout

            // Basic properties
            Log.d("API", "Title: ${workout.title}")
            Log.d("API", "Category: ${workout.category}")
            Log.d("API", "Duration: ${workout.totalMinutes} minutes")
            Log.d("API", "Calories: ${workout.calories}")

            // Body parts
            Log.d("API", "Targets: ${workout.bodyParts.joinToString(", ")}")

            // Exercise sequence
            Log.d("API", "Exercises (${workout.sequence.size}):")
            workout.sequence.forEachIndexed { index, exercise ->
                Log.d("API", "${index + 1}. ${exercise.title}")
                Log.d("API", "   Model ID: ${exercise.modelId}")  // Use for Camera Component
            }

            // Pretty print as JSON
            val gson = GsonBuilder().setPrettyPrinting().create()
            val prettyJson = gson.toJson(workout)
            Log.d("API", "JSON:\n$prettyJson")
        }
        is APIContentResult.Error -> {
            Log.e("API", "Error: ${result.message}")
        }
        else -> {}
    }
}
```

_Flutter_
```dart
// Accessing workout model properties
Future<void> workWithModels() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.workout,
    id: "9zE1kzOzpU5d5dAJrPOY",
  );

  switch (result) {
    case WorkoutResult(:final workout):
      // Basic properties
      print('Title: ${workout.title}');
      print('Category: ${workout.category}');
      print('Duration: ${workout.totalMinutes} minutes');
      print('Calories: ${workout.totalCalories}');
      print('Difficulty: ${workout.difficultyLevel}');

      // Body parts
      print('Targets: ${workout.bodyParts.join(", ")}');

      // Exercise sequence
      print('\nExercises (${workout.sequence.length}):');
      for (var i = 0; i < workout.sequence.length; i++) {
        final exercise = workout.sequence[i];
        print('${i + 1}. ${exercise.title}');
        print('   Model ID: ${exercise.modelId}');  // Use for Camera Component
      }

      // Access raw JSON if needed
      if (workout.rawJSON != null) {
        print('\nRaw JSON available: ${workout.rawJSON!.keys.length} keys');
      }

    case ErrorResult(:final message):
      print('Error: $message');

    default:
      break;
  }
}

// Working with plan structure
Future<void> workWithPlan() async {
  final result = await KinesteXAIFramework.apiService.fetchContent(
    contentType: ContentType.plan,
    id: "22B3qRU2r75hVXHgGiGx",
  );

  switch (result) {
    case PlanResult(:final plan):
      print('Plan: ${plan.title}');
      print('Category: ${plan.category.description}');

      // Iterate through levels
      plan.levels.forEach((levelKey, level) {
        print('\nLevel $levelKey: ${level.title}');

        // Iterate through days
        level.days.forEach((dayKey, day) {
          print('  Day $dayKey: ${day.title}');

          // List workouts for this day
          day.workouts?.forEach((workout) {
            print('    - ${workout.title} (${workout.totalMinutes} min)');
          });
        });
      });

    case ErrorResult(:final message):
      print('Error: $message');

    default:
      break;
  }
}
```

_React Native_
```jsx
// TypeScript interfaces for Content API models
interface WorkoutModel {
  id: string;
  title: string;
  category: string;
  calories: number;
  total_minutes: number;
  body_parts: string[];
  dif_level: string;
  description: string;
  workout_desc_img: string;
  sequence: ExerciseModel[];
}

interface ExerciseModel {
  id: string;
  title: string;
  body_parts: string[];
  video_url: string;
  male_video_url: string;
  thumbnail_url: string;
  male_thumbnail_url: string;
  model_id: string;
  description: string;
  steps: string[];
  common_mistakes: string;
  tips: string;
  workout_reps?: number;
  workout_countdown?: number;
  average_reps?: number;
  average_countdown?: number;
  rest_duration?: number;
}

interface PlanModel {
  id: string;
  title: string;
  img_url: string;
  category: {
    description: string;
    levels: Record<string, number>;
  };
  levels: Record<string, PlanLevel>;
  created_by: string;
}

interface PlanLevel {
  title: string;
  description: string;
  days: Record<string, PlanDay>;
}

interface PlanDay {
  title: string;
  description: string;
  workouts?: WorkoutSummary[];
}

interface WorkoutSummary {
  id: string;
  img_url: string;
  title: string;
  calories?: number;
  total_minutes: number;
}

// Working with fetched data
const displayWorkout = (workout: WorkoutModel) => {
  console.log(`Title: ${workout.title}`);
  console.log(`Duration: ${workout.total_minutes} minutes`);
  console.log(`Calories: ${workout.calories}`);
  console.log(`Targets: ${workout.body_parts.join(', ')}`);

  console.log(`\nExercises (${workout.sequence.length}):`);
  workout.sequence.forEach((exercise, index) => {
    console.log(`${index + 1}. ${exercise.title}`);
    console.log(`   Model ID: ${exercise.model_id}`);  // Use for Camera Component
  });
};
```

_HTML / JavaScript_
```html
// Working with fetched workout data
function displayWorkout(workout) {
  console.log(`Title: ${workout.title}`);
  console.log(`Duration: ${workout.total_minutes} minutes`);
  console.log(`Calories: ${workout.calories}`);
  console.log(`Targets: ${workout.body_parts.join(', ')}`);

  console.log(`\nExercises (${workout.sequence.length}):`);
  workout.sequence.forEach((exercise, index) => {
    console.log(`${index + 1}. ${exercise.title}`);
    console.log(`   Model ID: ${exercise.model_id}`);  // Use for Camera Component
  });
}

// Working with plan structure
function displayPlan(plan) {
  console.log(`Plan: ${plan.title}`);
  console.log(`Category: ${plan.category.description}`);

  // Iterate through levels
  Object.entries(plan.levels).forEach(([levelKey, level]) => {
    console.log(`\nLevel ${levelKey}: ${level.title}`);

    // Iterate through days
    Object.entries(level.days).forEach(([dayKey, day]) => {
      console.log(`  Day ${dayKey}: ${day.title}`);

      // List workouts for this day
      if (day.workouts) {
        day.workouts.forEach(workout => {
          console.log(`    - ${workout.title} (${workout.total_minutes} min)`);
        });
      }
    });
  });
}
```

_React (TypeScript)_
```tsx
// Full TypeScript interfaces for Content API models
interface WorkoutModel {
  id: string;
  title: string;
  category: string;
  calories: number;
  total_minutes: number;
  body_parts: string[];
  dif_level: string;
  description: string;
  workout_desc_img: string;
  sequence: ExerciseModel[];
}

interface ExerciseModel {
  id: string;
  title: string;
  body_parts: string[];
  video_url: string;
  male_video_url: string;
  thumbnail_url: string;
  male_thumbnail_url: string;
  model_id: string;
  description: string;
  steps: string[];
  common_mistakes: string;
  tips: string;
  workout_reps?: number;
  workout_countdown?: number;
  average_reps?: number;
  average_countdown?: number;
  rest_duration?: number;
}

interface PlanModel {
  id: string;
  title: string;
  img_url: string;
  category: PlanCategory;
  levels: Record<string, PlanLevel>;
  created_by: string;
}

interface PlanCategory {
  description: string;
  levels: Record<string, number>;
}

interface PlanLevel {
  title: string;
  description: string;
  days: Record<string, PlanDay>;
}

interface PlanDay {
  title: string;
  description: string;
  workouts?: WorkoutSummary[];
}

interface WorkoutSummary {
  id: string;
  img_url: string;
  title: string;
  calories?: number;
  total_minutes: number;
}

// Helper function to display workout
const displayWorkout = (workout: WorkoutModel): void => {
  console.log(`Title: ${workout.title}`);
  console.log(`Duration: ${workout.total_minutes} minutes`);
  console.log(`Calories: ${workout.calories}`);
  console.log(`Targets: ${workout.body_parts.join(', ')}`);

  console.log(`\nExercises (${workout.sequence.length}):`);
  workout.sequence.forEach((exercise, index) => {
    console.log(`${index + 1}. ${exercise.title}`);
    console.log(`   Model ID: ${exercise.model_id}`);  // Use for Camera Component
  });
};
```

---
Source: https://kinestex.com/docs/content-api/content-api-models · Index: https://kinestex.com/llms.txt