diff --git a/src/lib/types/index.ts b/src/lib/types/index.ts
index 2938557..6b95228 100644
--- a/src/lib/types/index.ts
+++ b/src/lib/types/index.ts
@@ -1,10 +1,51 @@
+export type Car = {
+  _id: number;
+  ai_enabled: boolean;
+  allow_number_colors: boolean;
+  allow_number_font: boolean;
+  allow_sponsor1: boolean;
+  allow_sponsor2: boolean;
+  allow_wheel_color: boolean;
+  award_exempt: boolean;
+  car_dirpath: string;
+  car_id: number;
+  car_name: string;
+  car_name_abbreviated: string;
+  car_types: Array<{ car_type: string }>;
+  car_weight: number;
+  categories: Array<string>;
+  created: string;
+  first_sale: string;
+  forum_url: string;
+  free_with_subscription: boolean;
+  has_headlights: boolean;
+  has_multiple_dry_tires_types: boolean;
+  hp: number;
+  is_ps_purchasable: boolean;
+  max_power_adjust_pct: number;
+  max_weight_penalty_kg: number;
+  min_power_adjust_pct: number;
+  package_id: number;
+  patterns: number;
+  price: number;
+  price_display: string;
+  retired: boolean;
+  search_filters: string;
+  sku: number;
+};
+
 export type CarClass = {
   car_class_id: number;
-  cars_in_class: Array<{ car_id: number }>;
+  cars_in_class: Array<{ car_id: number; car_name: string | undefined }>;
   name: string;
   short_name: string;
 };
 
+export type CarClassMapping = {
+  car_class_id: number;
+  car_class_short_name: string;
+};
+
 export type Helmet = {
   pattern: number;
   color1: string;
@@ -54,6 +95,155 @@ export type RaceSummary = {
   special_event_type_text: string;
 };
 
+export type RaceWeek = {
+  season_id: number;
+  race_week_num: number;
+  series_id: number;
+  series_name: string;
+  season_name: string;
+  schedule_name: string;
+  start_date: string;
+  simulated_time_multiplier: number;
+  race_lap_limit: number | null;
+  race_time_limit: number | null;
+  start_type: string;
+  restart_type: string;
+  qual_attached: boolean;
+  full_course_cautions: boolean;
+  special_event_type: unknown;
+  start_zone: boolean;
+  enable_pitlane_collisions: boolean;
+  short_parade_lap: boolean;
+  track: Track;
+  weather: Weather;
+  track_state: TrackState;
+  race_time_descriptors: Array<unknown>;
+  car_restrictions: Array<unknown>;
+  race_week_cars: Array<unknown>;
+};
+
+export type SchedulingSeason = {
+  _id: number;
+  active: boolean;
+  allowed_season_members: unknown;
+  car_class_ids: Array<number>;
+  car_switching: boolean;
+  car_types: Array<{ car_type: string }>;
+  caution_laps_do_not_count: boolean;
+  complete: boolean;
+  cross_license: boolean;
+  driver_change_rule: number;
+  driver_changes: boolean;
+  drops: number;
+  enable_pitlane_collisions: boolean;
+  fixed_setup: boolean;
+  green_white_checkered_limit: number;
+  grid_by_class: boolean;
+  hardcore_level: number;
+  ignore_license_for_practice: boolean;
+  incident_limit: number;
+  incidient_warn_mode: number;
+  incident_warn_param1: number;
+  incident_warn_param2: number;
+  is_heat_racing: boolean;
+  license_group: number;
+  license_group_types: Array<{ license_group_type: number }>;
+  lucky_dog: boolean;
+  max_team_drivers: number;
+  max_weeks: number;
+  min_team_drivers: number;
+  multiclass: boolean;
+  must_user_diff_tire_types_in_race: boolean;
+  next_race_session: unknown;
+  num_opt_laps: number;
+  official: boolean;
+  op_duration: number;
+  open_practice_session_type_id: number;
+  qualifier_must_start_race: boolean;
+  race_week: number;
+  race_week_to_make_division: number;
+  reg_user_count: number;
+  region_competition: boolean;
+  restrict_by_member: boolean;
+  restrict_to_car: boolean;
+  restrict_viewing: boolean;
+  schedule_description: string;
+  schedules: Array<RaceWeek>;
+  season_id: number;
+  season_name: string;
+  season_quarter: number;
+  season_short_name: string;
+  season_year: number;
+  send_to_open_practice: boolean;
+  series_id: number;
+  short_parade_lap: boolean;
+  start_date: string;
+  start_on_qual_tire: boolean;
+  start_zone: boolean;
+  track_types: Array<{ track_type: string }>;
+  unsport_conduct_rule_mode: number;
+};
+
+export type SchedulingTableResult = {
+  "Season Name": string;
+  "License Level": string;
+  carClassData: Array<CarClass>;
+  tracks: Array<Track>;
+  ownedTrackWeeks: Array<number>;
+  "Own Car": string;
+  "Overall Track Percentage Owned": number;
+};
+
+export type Season = {
+  _id: string;
+  car_class_id: string;
+  division: number;
+  overall_rank: number;
+  season_driver_data: SeasonDriverData;
+  season_id: string;
+  season_name: string;
+  division_rank: number;
+};
+
+export type SeasonDriverData = {
+  rank: number;
+  cust_id: number;
+  display_name: number;
+  division: number;
+  club_id: number;
+  club_name: string;
+  license: SeasonDriverLicense;
+  helmet: Helmet;
+  weeks_counted: number;
+  starts: number;
+  wins: number;
+  top5: number;
+  top25_percent: number;
+  poles: number;
+  avg_start_position: number;
+  avg_finish_position: number;
+  avg_field_size: number;
+  laps: number;
+  laps_led: number;
+  incidents: number;
+  points: number;
+  raw_points: number;
+  week_dropped: boolean;
+  country_code: string;
+  country: string;
+};
+
+export type SeasonDriverLicense = {
+  category_id: number;
+  category: string;
+  license_level: number;
+  safety_rating: number;
+  irating: number;
+  color: string;
+  group_name: string;
+  group_id: number;
+};
+
 export type Session = {
   simsession_number: number;
   simsession_type: number;
@@ -195,8 +385,9 @@ export type Track = {
   track_id: number;
   track_name: string;
   config_name: string;
-  category_id: number;
-  category: string;
+  category_id: number | undefined;
+  category: string | undefined;
+  race_week_num: number | undefined;
 };
 
 export type TrackState = {
@@ -211,6 +402,16 @@ export type TrackState = {
   race_grip_compound: number;
 };
 
+export type UserIdCarClassIdsMapping = {
+  userId: number;
+  carClassIds: Array<number>;
+};
+
+export type UserIdYearsMapping = {
+  userId: number;
+  years: Array<number>;
+};
+
 export type Weather = {
   version: number;
   type: number;
diff --git a/src/pages/subsession/[id].astro b/src/pages/subsession/[id].astro
index 7990d34..0b00c47 100644
--- a/src/pages/subsession/[id].astro
+++ b/src/pages/subsession/[id].astro
@@ -11,14 +11,13 @@ export async function getStaticPaths() {
 	const dbConnection = await connectToDatabase();
 	const db = dbConnection.db;
 	const collection = db.collection("subsessions");
-	const subsessionIds = await collection.distinct("_id", {});
-	return subsessionIds.map((id) => ({ params: { id: Number(id) } }));
+	const subsessionIds: Array<number> = await collection.distinct("_id", {});
+	return subsessionIds.map((id) => ({ params: { id } }));
 }
 const { id } = Astro.params;
 const dbConnection = await connectToDatabase();
 const db = dbConnection.db;
 const collection = db.collection<Subsession>("subsessions");
-//@ts-ignore
 const subsession: Subsession = await collection.findOne({ _id: Number(id) });
 const {
 	track,
@@ -65,8 +64,10 @@ const {
 				toggle() {
 					this.$el.id.split(" ").forEach((id, index) => {
 						if (index) {
+							// @ts-expect-error
 							this[id] = false;
 						} else {
+							// @ts-expect-error
 							this[id] = !this[id];
 						}
 					});
diff --git a/src/pages/user/[id]/scheduling/index.astro b/src/pages/user/[id]/scheduling/index.astro
index 8dde6e1..ab0b978 100644
--- a/src/pages/user/[id]/scheduling/index.astro
+++ b/src/pages/user/[id]/scheduling/index.astro
@@ -1,19 +1,25 @@
 ---
 import { connectToDatabase } from "$lib/mongodb";
 import DefaultLayout from "$lib/layouts/default.astro";
-// @todo Properly assert types in this file
+import type {
+  Car,
+  CarClass,
+  SchedulingSeason,
+  SchedulingTableResult,
+  Track,
+} from "$lib/types";
 export async function getStaticPaths() {
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const userCollection = db.collection("users");
-  const userIds = await userCollection.distinct("_id", {});
+  const userIds: Array<number> = await userCollection.distinct("_id", {});
   return userIds.map((id) => ({ params: { id } }));
 }
 const { id } = Astro.params;
 const dbConnection = await connectToDatabase();
 const db = dbConnection.db;
 const userCollection = db.collection("users");
-const carPackages = await userCollection
+const carPackages: Array<{ content_ids: Array<number> }> = await userCollection
   .aggregate([
     {
       $match: {
@@ -39,36 +45,37 @@ const carPackages = await userCollection
   ])
   .toArray();
 const carIds = carPackages.map((carPackage) => carPackage.content_ids).flat();
-const trackPackages = await userCollection
-  .aggregate([
-    {
-      $match: {
-        _id: Number(id),
+const trackPackages: Array<{ content_ids: Array<number> }> =
+  await userCollection
+    .aggregate([
+      {
+        $match: {
+          _id: Number(id),
+        },
       },
-    },
-    {
-      $unwind: "$track_packages",
-    },
-    {
-      $replaceRoot: {
-        newRoot: {
-          $mergeObjects: ["$track_packages", "$$ROOT"],
+      {
+        $unwind: "$track_packages",
+      },
+      {
+        $replaceRoot: {
+          newRoot: {
+            $mergeObjects: ["$track_packages", "$$ROOT"],
+          },
         },
       },
-    },
-    {
-      $project: {
-        _id: 0,
-        content_ids: 1,
+      {
+        $project: {
+          _id: 0,
+          content_ids: 1,
+        },
       },
-    },
-  ])
-  .toArray();
+    ])
+    .toArray();
 const trackIds = trackPackages
   .map((trackPackage) => trackPackage.content_ids)
   .flat();
 const carsCollection = db.collection("cars");
-const cars = await carsCollection.find().toArray();
+const cars: Array<Car> = await carsCollection.find().toArray();
 const carsMap = new Map();
 cars.forEach((car) => {
   const { car_id } = car;
@@ -78,7 +85,7 @@ const carClassCollection = db.collection("carclasses");
 const carClassIdsForCarIds = await carClassCollection.distinct("car_class_id", {
   "cars_in_class.car_id": { $in: carIds },
 });
-const carClasses = await carClassCollection.find().toArray();
+const carClasses: Array<CarClass> = await carClassCollection.find().toArray();
 const carClassesMap = new Map();
 carClasses.forEach((carClass) => {
   const { car_class_id, cars_in_class } = carClass;
@@ -88,7 +95,9 @@ carClasses.forEach((carClass) => {
   carClassesMap.set(car_class_id, { ...carClass, cars_in_class: carsInClass });
 });
 const seasonsCollection = db.collection("seasons");
-const seasons = await seasonsCollection.find({}, {}).toArray();
+const seasons: Array<SchedulingSeason> = await seasonsCollection
+  .find({}, {})
+  .toArray();
 const carClassIdSet = new Set(carClassIdsForCarIds);
 const trackIdSet = new Set(trackIds);
 const licenseGroupToNameMap: Record<string, string> = {
@@ -98,23 +107,21 @@ const licenseGroupToNameMap: Record<string, string> = {
   "4": "Class B",
   "5": "Class A",
 };
-const results = seasons
+const results: Array<SchedulingTableResult> = seasons
   .map((season) => {
     const { schedules, season_name, car_class_ids } = season;
-    const carClassData = car_class_ids.map((car_class_id: number) =>
-      carClassesMap.get(car_class_id)
+    const carClassData: Array<CarClass> = car_class_ids.map(
+      (car_class_id: number) => carClassesMap.get(car_class_id)
     );
-    const tracks: Array<Record<string, unknown>> = schedules.map(
+    const tracks: Array<Track> = schedules.map(
       (schedule: any, index: number) => ({
-        week: index + 1,
+        race_week_num: index + 1,
         ...schedule.track,
       })
     );
     const ownedTrackWeeks: Array<number> = tracks
-      .filter((track: Record<string, unknown>) =>
-        trackIdSet.has(track.track_id)
-      )
-      .map((track: Record<string, unknown>) => Number(track.week));
+      .filter((track: Track) => trackIdSet.has(track.track_id))
+      .map((track) => Number(track.race_week_num));
     const trackPercentageOwned = Math.round(
       (ownedTrackWeeks.length / tracks.length) * 100
     );
@@ -157,8 +164,11 @@ const keysToOmitInTable = new Set([
           x-on:click="toggle"
         >
           {Object.keys(result)
-            .filter((key) => !keysToOmitInTable.has(key))
-            .map((key: string) => (
+            .filter(
+              (key): key is keyof SchedulingTableResult =>
+                !keysToOmitInTable.has(key)
+            )
+            .map((key) => (
               <div class="border-2 col-span-1">{result[key]}</div>
             ))}
           <div
@@ -188,13 +198,15 @@ const keysToOmitInTable = new Set([
             </div>
             <div class="col-span-2 border-x-2">
               {result.tracks.map((track) =>
-                result.ownedTrackWeeks.includes(Number(track.week)) ? (
+                result.ownedTrackWeeks.includes(Number(track.race_week_num)) ? (
                   <div class="bg-green-950">
-                    {track.week}. {track.track_name} {track.config_name}
+                    {track.race_week_num}. {track.track_name}{" "}
+                    {track.config_name}
                   </div>
                 ) : (
                   <div class="bg-red-950">
-                    {track.week}. {track.track_name} {track.config_name}
+                    {track.race_week_num}. {track.track_name}{" "}
+                    {track.config_name}
                   </div>
                 )
               )}
@@ -206,6 +218,7 @@ const keysToOmitInTable = new Set([
   </div>
   <script>
     import Alpine from "alpinejs";
+    // @ts-expect-error
     import collapse from "@alpinejs/collapse";
     Alpine.plugin(collapse);
     Alpine.data("dropdown", () => ({
diff --git a/src/pages/user/[id]/season/[seasonId]/index.astro b/src/pages/user/[id]/season/[seasonId]/index.astro
index fde177d..d86f551 100644
--- a/src/pages/user/[id]/season/[seasonId]/index.astro
+++ b/src/pages/user/[id]/season/[seasonId]/index.astro
@@ -4,13 +4,13 @@ import fieldIdToLabelMap from "$lib/utils/field-id-to-label-map";
 import lapTimeFields from "$lib/utils/lap-time-fields";
 import parseLapTime from "$lib/utils/parse-lap-time";
 import { connectToDatabase } from "$lib/mongodb";
-import type { Subsession } from "$lib/types";
+import type { Season, Subsession } from "$lib/types";
 import userIds from "$lib/utils/user-ids";
 export async function getStaticPaths() {
 	const dbConnection = await connectToDatabase();
 	const db = dbConnection.db;
 	const collection = db.collection("standings");
-	const seasons = await collection
+	const seasons: Array<Season> = await collection
 		.find({ "season_driver_data.cust_id": { $in: userIds } })
 		.toArray();
 	return seasons.map((season) => ({
@@ -24,7 +24,7 @@ const { id, seasonId } = Astro.params;
 const dbConnection = await connectToDatabase();
 const db = dbConnection.db;
 const collection = db.collection<Subsession>("subsessions");
-const subsessions = await collection
+const subsessions: Array<Subsession> = await collection
 	.find({
 		season_id: Number(seasonId),
 		"session_results.2.results": { $elemMatch: { cust_id: Number(id) } },
diff --git a/src/pages/user/[id]/season/[seasonId]/season-summary.astro b/src/pages/user/[id]/season/[seasonId]/season-summary.astro
index ab71462..546987c 100644
--- a/src/pages/user/[id]/season/[seasonId]/season-summary.astro
+++ b/src/pages/user/[id]/season/[seasonId]/season-summary.astro
@@ -4,14 +4,14 @@ import fieldIdToLabelMap from "$lib/utils/field-id-to-label-map";
 import lapTimeFields from "$lib/utils/lap-time-fields";
 import parseLapTime from "$lib/utils/parse-lap-time";
 import { connectToDatabase } from "$lib/mongodb";
-import type { Subsession, Track } from "$lib/types";
+import type { License, Season, SessionResult, Subsession, Track } from "$lib/types";
 import userIds from "$lib/utils/user-ids";
 // @todo Properly assert types in this file
 export async function getStaticPaths() {
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("standings");
-  const seasons = await collection
+  const seasons: Array<Season> = await collection
     .find({ "season_driver_data.cust_id": { $in: userIds } })
     .toArray();
   return seasons.map((season) => ({
@@ -25,7 +25,7 @@ const { id, seasonId } = Astro.params;
 const dbConnection = await connectToDatabase();
 const db = dbConnection.db;
 const subsessionCollection = db.collection<Subsession>("subsessions");
-const subsessions = await subsessionCollection
+const subsessions: Array<Subsession> = await subsessionCollection
   .find({
     season_id: Number(seasonId),
     "session_results.2.results": { $elemMatch: { cust_id: Number(id) } },
@@ -49,11 +49,11 @@ const trackSchedule: Array<Track> = pastSeasonInformation.race_weeks.map(
 );
 const trackScheduleMap: Map<number, Track> = new Map();
 trackSchedule.forEach((track) => {
-  trackScheduleMap.set(track.race_week_num, track);
+  trackScheduleMap.set(Number(track.race_week_num), track);
 });
 
-const resultsPerWeek = [];
-trackScheduleMap.forEach((value, key) => {
+const resultsPerWeek: Array<{subsession: Subsession, userResult: SessionResult}> = [];
+trackScheduleMap.forEach((value) => {
   const respectiveSubsessions = subsessions.filter(
     (subsession) =>
       Number(subsession.race_week_num) === Number(value.race_week_num)
@@ -68,20 +68,22 @@ trackScheduleMap.forEach((value, key) => {
     const bestUserResult = userResults
       .sort(
         (a, b) =>
-          a.userResult.aggregate_champ_points >
+          a.userResult.aggregate_champ_points -
           b.userResult.aggregate_champ_points
       )
       .pop();
-    resultsPerWeek.push(bestUserResult);
+    if (bestUserResult) {
+      resultsPerWeek.push(bestUserResult);
+    }
   } else if (userResults.length === 0) {
     const bestUserResult = { subsession: { track: value }, userResult: {} };
+    // @ts-expect-error
     resultsPerWeek.push(bestUserResult);
   } else {
     const [bestUserResult] = userResults;
     resultsPerWeek.push(bestUserResult);
   }
 });
-
 const results = resultsPerWeek.map((result) => {
   const { subsession, userResult } = result;
   const {
@@ -112,6 +114,7 @@ const results = resultsPerWeek.map((result) => {
     car_name,
     aggregate_champ_points,
   } = userResult;
+  // @ts-expect-error
   const { group_name: License } =
     allowed_licenses && allowed_licenses.length
       ? allowed_licenses.slice(0, 2).pop()
diff --git a/src/pages/user/[id]/standings/by-car-class/[carClassId].astro b/src/pages/user/[id]/standings/by-car-class/[carClassId].astro
index 87b0111..c92545d 100644
--- a/src/pages/user/[id]/standings/by-car-class/[carClassId].astro
+++ b/src/pages/user/[id]/standings/by-car-class/[carClassId].astro
@@ -2,18 +2,20 @@
 import { connectToDatabase } from "$lib/mongodb";
 import StandingsLayout from "$lib/layouts/standings.astro";
 import userIds from "$lib/utils/user-ids";
+import type { UserIdCarClassIdsMapping } from "$lib/types";
 export async function getStaticPaths() {
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("standings");
-  const mappings = await Promise.all(
-    userIds.map(async (userId) => ({
-      userId,
-      carClassIds: await collection.distinct("car_class_id", {
-        "season_driver_data.cust_id": Number(userId),
-      }),
-    }))
-  );
+  const mappings: Array<UserIdCarClassIdsMapping> =
+    await Promise.all(
+      userIds.map(async (userId) => ({
+        userId,
+        carClassIds: await collection.distinct("car_class_id", {
+          "season_driver_data.cust_id": Number(userId),
+        }),
+      }))
+    );
   return mappings
     .map((mapping) => {
       const { userId, carClassIds } = mapping;
diff --git a/src/pages/user/[id]/standings/by-car-class/index.astro b/src/pages/user/[id]/standings/by-car-class/index.astro
index 799e733..a75ee16 100644
--- a/src/pages/user/[id]/standings/by-car-class/index.astro
+++ b/src/pages/user/[id]/standings/by-car-class/index.astro
@@ -2,6 +2,7 @@
   import { connectToDatabase } from "$lib/mongodb";
   import DefaultLayout from "$lib/layouts/default.astro";
 	import userIds from "$lib/utils/user-ids";
+	import type { CarClassMapping } from "$lib/types";
 	export function getStaticPaths() {
 		return userIds.map((id) => ({ params: { id } }));
 	}
@@ -9,7 +10,7 @@
 	const dbConnection = await connectToDatabase();
 	const db = dbConnection.db;
   const collection = db.collection("subsessions");
-	const allUserSubsessionCarClasses = await collection.aggregate([
+	const allUserSubsessionCarClasses: Array<CarClassMapping> = await collection.aggregate([
 		{
 			"$match": {
 				"session_results.2.results": { $elemMatch: { cust_id: Number(id) } },
diff --git a/src/pages/user/[id]/standings/by-year/[year].astro b/src/pages/user/[id]/standings/by-year/[year].astro
index ebf011a..7adc6b5 100644
--- a/src/pages/user/[id]/standings/by-year/[year].astro
+++ b/src/pages/user/[id]/standings/by-year/[year].astro
@@ -2,25 +2,36 @@
 import { connectToDatabase } from "$lib/mongodb";
 import StandingsLayout from "$lib/layouts/standings.astro";
 import userIds from "$lib/utils/user-ids";
+import type { UserIdYearsMapping } from "$lib/types";
 export async function getStaticPaths() {
-	const dbConnection = await connectToDatabase();
-	const db = dbConnection.db;
-	const collection = db.collection("subsessions");
-  const mappings = await Promise.all(userIds.map(async (userId) => ({
-    userId,
-    years: await collection.distinct("season_year", { "session_results.2.results": { $elemMatch: { cust_id: userId } }}),
-  })));
-  return mappings.map((mapping) => {
-    const { userId, years } = mapping;
-    return years.map((year) => ({ params: { id: userId, year }}));
-  }).flat();
+  const dbConnection = await connectToDatabase();
+  const db = dbConnection.db;
+  const collection = db.collection("subsessions");
+  const mappings: Array<UserIdYearsMapping> =
+    await Promise.all(
+      userIds.map(async (userId) => ({
+        userId,
+        years: await collection.distinct("season_year", {
+          "session_results.2.results": { $elemMatch: { cust_id: userId } },
+        }),
+      }))
+    );
+  return mappings
+    .map((mapping) => {
+      const { userId, years } = mapping;
+      return years.map((year) => ({ params: { id: userId, year } }));
+    })
+    .flat();
 }
 const { id, year } = Astro.params;
 const dbConnection = await connectToDatabase();
 const { db } = dbConnection;
 const collection = db.collection("standings");
 const standingsResults = await collection
-  .find({ "season_driver_data.cust_id": Number(id), season_name: { $regex: year } })
+  .find({
+    "season_driver_data.cust_id": Number(id),
+    season_name: { $regex: year },
+  })
   .sort({ season_id: -1 })
   .toArray();
 ---
diff --git a/src/pages/user/[id]/standings/by-year/index.astro b/src/pages/user/[id]/standings/by-year/index.astro
index a4ea0fd..430c8c0 100644
--- a/src/pages/user/[id]/standings/by-year/index.astro
+++ b/src/pages/user/[id]/standings/by-year/index.astro
@@ -9,7 +9,7 @@
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("subsessions");
-  const years = await collection.distinct("season_year", { "session_results.2.results": { $elemMatch: { cust_id: Number(id) } } });
+  const years: Array<number> = await collection.distinct("season_year", { "session_results.2.results": { $elemMatch: { cust_id: Number(id) } } });
 ---
 
 
diff --git a/src/pages/user/[id]/subsessions/by-car-class/[carClassId].astro b/src/pages/user/[id]/subsessions/by-car-class/[carClassId].astro
index 8eb4bef..c0c5955 100644
--- a/src/pages/user/[id]/subsessions/by-car-class/[carClassId].astro
+++ b/src/pages/user/[id]/subsessions/by-car-class/[carClassId].astro
@@ -2,18 +2,20 @@
 import { connectToDatabase } from "$lib/mongodb";
 import SubsessionsLayout from "$lib/layouts/subsessions.astro";
 import userIds from "$lib/utils/user-ids";
+import type { UserIdCarClassIdsMapping } from "$lib/types";
 export async function getStaticPaths() {
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("standings");
-  const mappings = await Promise.all(
-    userIds.map(async (userId) => ({
-      userId,
-      carClassIds: await collection.distinct("car_class_id", {
-        "season_driver_data.cust_id": Number(userId),
-      }),
-    }))
-  );
+  const mappings: Array<UserIdCarClassIdsMapping> =
+    await Promise.all(
+      userIds.map(async (userId) => ({
+        userId,
+        carClassIds: await collection.distinct("car_class_id", {
+          "season_driver_data.cust_id": Number(userId),
+        }),
+      }))
+    );
   return mappings
     .map((mapping) => {
       const { userId, carClassIds } = mapping;
diff --git a/src/pages/user/[id]/subsessions/by-car-class/index.astro b/src/pages/user/[id]/subsessions/by-car-class/index.astro
index 7362506..f3013df 100644
--- a/src/pages/user/[id]/subsessions/by-car-class/index.astro
+++ b/src/pages/user/[id]/subsessions/by-car-class/index.astro
@@ -2,6 +2,7 @@
   import { connectToDatabase } from "$lib/mongodb";
   import DefaultLayout from "$lib/layouts/default.astro";
 	import userIds from "$lib/utils/user-ids";
+	import type { CarClassMapping } from "$lib/types";
 	export function getStaticPaths() {
 		return userIds.map((id) => ({ params: { id } }));
 	}
@@ -9,7 +10,7 @@
 	const dbConnection = await connectToDatabase();
 	const db = dbConnection.db;
   const collection = db.collection("subsessions");
-	const allUserSubsessionCarClasses = await collection.aggregate([
+	const allUserSubsessionCarClasses: Array<CarClassMapping> = await collection.aggregate([
 		{
 			"$match": {
 				"session_results.2.results": { $elemMatch: { cust_id: Number(id) } },
diff --git a/src/pages/user/[id]/subsessions/by-year/[year].astro b/src/pages/user/[id]/subsessions/by-year/[year].astro
index 8e3e02b..a50a6ac 100644
--- a/src/pages/user/[id]/subsessions/by-year/[year].astro
+++ b/src/pages/user/[id]/subsessions/by-year/[year].astro
@@ -2,11 +2,12 @@
 import { connectToDatabase } from "$lib/mongodb";
 import SubsessionsLayout from "$lib/layouts/subsessions.astro";
 import userIds from "$lib/utils/user-ids";
+import type { UserIdYearsMapping } from "$lib/types";
 export async function getStaticPaths() {
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("subsessions");
-  const mappings = await Promise.all(
+  const mappings: Array<UserIdYearsMapping> = await Promise.all(
     userIds.map(async (userId) => ({
       userId,
       years: await collection.distinct("season_year", {
diff --git a/src/pages/user/[id]/subsessions/by-year/index.astro b/src/pages/user/[id]/subsessions/by-year/index.astro
index f658f15..18f53c2 100644
--- a/src/pages/user/[id]/subsessions/by-year/index.astro
+++ b/src/pages/user/[id]/subsessions/by-year/index.astro
@@ -9,7 +9,7 @@
   const dbConnection = await connectToDatabase();
   const db = dbConnection.db;
   const collection = db.collection("subsessions");
-  const years = await collection.distinct("season_year", { "session_results.2.results": { $elemMatch: { cust_id: Number(id) } } });
+  const years: Array<number> = await collection.distinct("season_year", { "session_results.2.results": { $elemMatch: { cust_id: Number(id) } } });
 ---