tbarequest 1.0.1 → 1.0.2

package/dist/index.js

@@ -1,69 +1,1380 @@
-import { tryCatch } from "./utils.js";
-import { endpoints } from "./types/endpoints/index.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/utils.ts
+async function tryCatch(promise) {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+
+// src/types/schemas/teams.ts
+import { type } from "arktype";
+var Team_Simple = type({
+  key: "string",
+  team_number: "number",
+  nickname: "string",
+  name: "string",
+  city: "string | null",
+  state_prov: "string | null",
+  country: "string | null"
+});
+var Team = Team_Simple.and({
+  postal_code: "string | null",
+  "website?": "string | null",
+  rookie_year: "number | null"
+});
+var Award_Recipient = type({
+  team_key: "string | null",
+  awardee: "string | null"
+});
+var Award = type({
+  name: "string",
+  award_type: "number",
+  event_key: "string",
+  recipient_list: Award_Recipient.array(),
+  year: "number"
+});
+var Team_Robot = type({
+  year: "number",
+  robot_name: "string",
+  key: "string",
+  team_key: "string"
+});
+var Media = type({
+  type: "string",
+  foreign_key: "string",
+  "details?": type({ "[string]": "unknown" }),
+  preferred: "boolean?",
+  team_keys: "string[]",
+  direct_url: "string?",
+  view_url: "string?"
+});
+
+// src/types/schemas/districts.ts
+import { type as type2 } from "arktype";
+var District_List = type2({
+  abbreviation: "string",
+  display_name: "string",
+  key: "string",
+  year: "number"
+});
+var District_Ranking = type2({
+  team_key: "string",
+  rank: "number",
+  rookie_bonus: "number?",
+  point_total: "number",
+  event_point: type2({
+    district_cmp: "boolean",
+    total: "number",
+    alliance_points: "number",
+    elim_points: "number",
+    award_points: "number",
+    event_key: "string",
+    qual_points: "number"
+  }).array().optional()
+});
+var District_Advancement = type2({
+  dcmp: "boolean",
+  cmp: "boolean"
+});
+
+// src/types/schemas/events.ts
+import { type as type3 } from "arktype";
+var Webcast = type3({
+  type: "'youtube' | 'twitch' | 'ustream' | 'iframe' | 'html5' | 'rtmp' | 'livestream' | 'direct_link' | 'mms' | 'justin' | 'stemtv' | 'dacast'",
+  channel: "string",
+  "date?": "string | null",
+  file: "(string | null)?"
+});
+var Event_Simple = type3({
+  key: "string",
+  name: "string",
+  event_code: "string",
+  event_type: "number",
+  district: type3(District_List, "|", "null"),
+  city: "string | null",
+  state_prov: "string | null",
+  country: "string | null",
+  start_date: "string",
+  end_date: "string",
+  year: "number"
+});
+var Event = Event_Simple.and({
+  short_name: "string | null",
+  event_type_string: "string",
+  week: "number | null",
+  address: "string | null",
+  postal_code: "string | null",
+  gmaps_place_id: "string | null",
+  gmaps_url: "string | null",
+  lat: "number | null",
+  lng: "number | null",
+  location_name: "string | null",
+  timezone: "string | null",
+  website: "string | null",
+  first_event_id: "string | null",
+  first_event_code: "string | null",
+  webcasts: Webcast.array(),
+  division_keys: "string[]",
+  parent_event_key: "string | null",
+  playoff_type: "number | null",
+  playoff_type_string: "string | null"
+});
+var WLT_Record = type3({
+  wins: "number",
+  losses: "number",
+  ties: "number"
+});
+var Team_Event_Status_rank = type3({
+  num_teams: "number | null",
+  ranking: type3({
+    matches_played: "number | null",
+    qual_average: "number | null",
+    sort_orders: "number[] | null",
+    rank: "number | null",
+    dq: "number | null",
+    team_key: "string | null"
+  }).optional(),
+  sort_order_info: type3(
+    {
+      precision: "number | null",
+      name: "string | null"
+    },
+    "|",
+    "null"
+  ).array(),
+  status: "string | null"
+}).partial();
+var Team_Event_Status_alliance_backup = type3({
+  in: "string?",
+  out: "string?"
+});
+var Team_Event_Status_alliance = type3({
+  name: "(string | null)?",
+  number: "number",
+  backup: type3(Team_Event_Status_alliance_backup, "|", "null").optional(),
+  pick: "number"
+});
+var Team_Event_Status_playoff = type3({
+  "level?": "'qm' | 'ef' | 'qf' | 'sf' | 'f'",
+  current_level_record: type3(WLT_Record, "|", "null").optional(),
+  record: type3(WLT_Record, "|", "null").optional(),
+  "status?": "'won' | 'eliminated' | 'playing'",
+  "playoff_average?": "number | null"
+});
+var Team_Event_Status = type3({
+  alliance_status_str: "string?",
+  playoff_status_str: "string?",
+  overall_status_str: "string?",
+  next_match_key: "(string | null)?",
+  last_match_key: "(string | null)?",
+  playoff: type3(Team_Event_Status_playoff, "|", "null").optional(),
+  qual: type3(Team_Event_Status_rank, "|", "null").optional(),
+  alliance: type3(Team_Event_Status_alliance, "|", "null").optional()
+});
+var Elimination_Alliance = type3({
+  name: "(string | null)?",
+  backup: type3(
+    {
+      in: "string",
+      out: "string"
+    },
+    "|",
+    "null"
+  ).optional(),
+  declines: "string[]",
+  picks: "string[]",
+  status: type3({
+    playoff_average: "number | null",
+    level: "string",
+    record: type3(WLT_Record, "|", "null"),
+    current_level_record: type3(WLT_Record, "|", "null"),
+    status: "string"
+  }).partial().optional()
+});
+
+// src/types/schemas/matches.ts
+import { type as type4 } from "arktype";
+var reef = type4({
+  botRow: {
+    nodeA: "boolean",
+    nodeB: "boolean",
+    nodeC: "boolean",
+    nodeD: "boolean",
+    nodeE: "boolean",
+    nodeF: "boolean",
+    nodeG: "boolean",
+    nodeH: "boolean",
+    nodeI: "boolean",
+    nodeJ: "boolean",
+    nodeK: "boolean",
+    nodeL: "boolean"
+  },
+  midRow: {
+    nodeA: "boolean",
+    nodeB: "boolean",
+    nodeC: "boolean",
+    nodeD: "boolean",
+    nodeE: "boolean",
+    nodeF: "boolean",
+    nodeG: "boolean",
+    nodeH: "boolean",
+    nodeI: "boolean",
+    nodeJ: "boolean",
+    nodeK: "boolean",
+    nodeL: "boolean"
+  },
+  topRow: {
+    nodeA: "boolean",
+    nodeB: "boolean",
+    nodeC: "boolean",
+    nodeD: "boolean",
+    nodeE: "boolean",
+    nodeF: "boolean",
+    nodeG: "boolean",
+    nodeH: "boolean",
+    nodeI: "boolean",
+    nodeJ: "boolean",
+    nodeK: "boolean",
+    nodeL: "boolean"
+  },
+  trough: "number",
+  tba_botRowCount: "number",
+  tba_midRowCount: "number",
+  tba_topRowCount: "number"
+});
+var matchScoreBreakdownYearsAlliances = {
+  "2015": type4({
+    adjust_points: "number",
+    auto_points: "number",
+    container_count_level1: "number",
+    container_count_level2: "number",
+    container_count_level3: "number",
+    container_count_level4: "number",
+    container_count_level5: "number",
+    container_count_level6: "number",
+    container_points: "number",
+    container_set: "boolean",
+    foul_count: "number",
+    foul_points: "number",
+    litter_count_container: "number",
+    litter_count_landfill: "number",
+    litter_count_unprocessed: "number",
+    litter_points: "number",
+    robot_set: "boolean",
+    teleop_points: "number",
+    total_points: "number",
+    tote_count_far: "number",
+    tote_count_near: "number",
+    tote_points: "number",
+    tote_set: "boolean",
+    tote_stack: "boolean"
+  }).partial(),
+  "2016": type4({
+    adjustPoints: "number",
+    autoBoulderPoints: "number",
+    autoBouldersHigh: "number",
+    autoBouldersLow: "number",
+    autoCrossingPoints: "number",
+    autoPoints: "number",
+    autoReachPoints: "number",
+    breachPoints: "number",
+    capturePoints: "number",
+    foulCount: "number",
+    foulPoints: "number",
+    position1crossings: "number",
+    position2: "string",
+    position2crossings: "number",
+    position3: "string",
+    position3crossings: "number",
+    position4: "string",
+    position4crossings: "number",
+    position5: "string",
+    position5crossings: "number",
+    robot1Auto: "'Crossed' | 'Reached' | 'None'",
+    robot2Auto: "string",
+    robot3Auto: "string",
+    tba_rpEarned: "number",
+    techFoulCount: "number",
+    teleopBoulderPoints: "number",
+    teleopBouldersHigh: "number",
+    teleopBouldersLow: "number",
+    teleopChallengePoints: "number",
+    teleopCrossingPoints: "number",
+    teleopDefensesBreached: "boolean",
+    teleopPoints: "number",
+    teleopScalePoints: "number",
+    teleopTowerCaptured: "boolean",
+    totalPoints: "number",
+    towerEndStrength: "number",
+    towerFaceA: "string",
+    towerFaceB: "string",
+    towerFaceC: "string"
+  }).partial(),
+  "2017": type4({
+    adjustPoints: "number",
+    autoFuelHigh: "number",
+    autoFuelLow: "number",
+    autoFuelPoints: "number",
+    autoMobilityPoints: "number",
+    autoPoints: "number",
+    autoRotorPoints: "number",
+    foulCount: "number",
+    foulPoints: "number",
+    kPaBonusPoints: "number",
+    kPaRankingPointAchieved: "boolean",
+    robot1Auto: "'Unknown' | 'Mobility' | 'None'",
+    robot2Auto: "'Unknown' | 'Mobility' | 'None'",
+    robot3Auto: "'Unknown' | 'Mobility' | 'None'",
+    rotor1Auto: "boolean",
+    rotor1Engaged: "boolean",
+    rotor2Auto: "boolean",
+    rotor2Engaged: "boolean",
+    rotor3Engaged: "boolean",
+    rotor4Engaged: "boolean",
+    rotorBonusPoints: "number",
+    rotorRankingPointAchieved: "boolean",
+    tba_rpEarned: "number",
+    techFoulCount: "number",
+    teleopFuelHigh: "number",
+    teleopFuelLow: "number",
+    teleopFuelPoints: "number",
+    teleopPoints: "number",
+    teleopRotorPoints: "number",
+    teleopTakeoffPoints: "number",
+    totalPoints: "number",
+    touchpadFar: "string",
+    touchpadMiddle: "string",
+    touchpadNear: "string"
+  }).partial(),
+  "2018": type4({
+    adjustPoints: "number",
+    autoOwnershipPoints: "number",
+    autoPoints: "number",
+    autoQuestRankingPoint: "boolean",
+    autoRobot1: "string",
+    autoRobot2: "string",
+    autoRobot3: "string",
+    autoRunPoints: "number",
+    autoScaleOwnershipSec: "number",
+    autoSwitchAtZero: "boolean",
+    autoSwitchOwnershipSec: "number",
+    endgamePoints: "number",
+    endgameRobot1: "string",
+    endgameRobot2: "string",
+    endgameRobot3: "string",
+    faceTheBossRankingPoint: "boolean",
+    foulCount: "number",
+    foulPoints: "number",
+    rp: "number",
+    tba_gameData: "string",
+    techFoulCount: "number",
+    teleopOwnershipPoints: "number",
+    teleopPoints: "number",
+    teleopScaleBoostSec: "number",
+    teleopScaleForceSec: "number",
+    teleopScaleOwnershipSec: "number",
+    teleopSwitchBoostSec: "number",
+    teleopSwitchForceSec: "number",
+    teleopSwitchOwnershipSec: "number",
+    totalPoints: "number",
+    vaultBoostPlayed: "number",
+    vaultBoostTotal: "number",
+    vaultForcePlayed: "number",
+    vaultForceTotal: "number",
+    vaultLevitatePlayed: "number",
+    vaultLevitateTotal: "number",
+    vaultPoints: "number"
+  }).partial(),
+  "2019": type4({
+    adjustPoints: "number",
+    autoPoints: "number",
+    bay1: "string",
+    bay2: "string",
+    bay3: "string",
+    bay4: "string",
+    bay5: "string",
+    bay6: "string",
+    bay7: "string",
+    bay8: "string",
+    cargoPoints: "number",
+    completeRocketRankingPoint: "boolean",
+    completedRocketFar: "boolean",
+    completedRocketNear: "boolean",
+    endgameRobot1: "string",
+    endgameRobot2: "string",
+    endgameRobot3: "string",
+    foulCount: "number",
+    foulPoints: "number",
+    habClimbPoints: "number",
+    habDockingRankingPoint: "boolean",
+    habLineRobot1: "string",
+    habLineRobot2: "string",
+    habLineRobot3: "string",
+    hatchPanelPoints: "number",
+    lowLeftRocketFar: "string",
+    lowLeftRocketNear: "string",
+    lowRightRocketFar: "string",
+    lowRightRocketNear: "string",
+    midLeftRocketFar: "string",
+    midLeftRocketNear: "string",
+    midRightRocketFar: "string",
+    midRightRocketNear: "string",
+    preMatchBay1: "string",
+    preMatchBay2: "string",
+    preMatchBay3: "string",
+    preMatchBay6: "string",
+    preMatchBay7: "string",
+    preMatchBay8: "string",
+    preMatchLevelRobot1: "string",
+    preMatchLevelRobot2: "string",
+    preMatchLevelRobot3: "string",
+    rp: "number",
+    sandStormBonusPoints: "number",
+    techFoulCount: "number",
+    teleopPoints: "number",
+    topLeftRocketFar: "string",
+    topLeftRocketNear: "string",
+    topRightRocketFar: "string",
+    topRightRocketNear: "string",
+    totalPoints: "number"
+  }).partial(),
+  "2020": type4({
+    adjustPoints: "number",
+    autoCellPoints: "number",
+    autoCellsBottom: "number",
+    autoCellsInner: "number",
+    autoCellsOuter: "number",
+    autoInitLinePoints: "number",
+    autoPoints: "number",
+    controlPanelPoints: "number",
+    endgamePoints: "number",
+    endgameRobot1: "string",
+    endgameRobot2: "string",
+    endgameRobot3: "string",
+    endgameRungIsLevel: "string",
+    foulCount: "number",
+    foulPoints: "number",
+    initLineRobot1: "string",
+    initLineRobot2: "string",
+    initLineRobot3: "string",
+    rp: "number",
+    shieldEnergizedRankingPoint: "boolean",
+    shieldOperationalRankingPoint: "boolean",
+    stage1Activated: "boolean",
+    stage2Activated: "boolean",
+    stage3Activated: "boolean",
+    stage3TargetColor: "string",
+    tba_numRobotsHanging: "number",
+    tba_shieldEnergizedRankingPointFromFoul: "boolean",
+    techFoulCount: "number",
+    teleopCellPoints: "number",
+    teleopCellsBottom: "number",
+    teleopCellsInner: "number",
+    teleopCellsOuter: "number",
+    teleopPoints: "number",
+    totalPoints: "number"
+  }).partial(),
+  "2022": type4({
+    adjustPoints: "number",
+    autoCargoLowerBlue: "number",
+    autoCargoLowerFar: "number",
+    autoCargoLowerNear: "number",
+    autoCargoLowerRed: "number",
+    autoCargoPoints: "number",
+    autoCargoTotal: "number",
+    autoCargoUpperBlue: "number",
+    autoCargoUpperFar: "number",
+    autoCargoUpperNear: "number",
+    autoCargoUpperRed: "number",
+    autoPoints: "number",
+    autoTaxiPoints: "number",
+    cargoBonusRankingPoint: "boolean",
+    endgamePoints: "number",
+    endgameRobot1: "'Transversal' | 'High' | 'Mid' | 'Low' | 'None'",
+    endgameRobot2: "'Transversal' | 'High' | 'Mid' | 'Low' | 'None'",
+    endgameRobot3: "'Transversal' | 'High' | 'Mid' | 'Low' | 'None'",
+    foulCount: "number",
+    foulPoints: "number",
+    hangarBonusRankingPoint: "boolean",
+    matchCargoTotal: "number",
+    quintetAchieved: "boolean",
+    rp: "number",
+    taxiRobot1: "'Yes' | 'No'",
+    taxiRobot2: "'Yes' | 'No'",
+    taxiRobot3: "'Yes' | 'No'",
+    techFoulCount: "number",
+    teleopCargoLowerBlue: "number",
+    teleopCargoLowerFar: "number",
+    teleopCargoLowerNear: "number",
+    teleopCargoLowerRed: "number",
+    teleopCargoPoints: "number",
+    teleopCargoTotal: "number",
+    teleopCargoUpperBlue: "number",
+    teleopCargoUpperFar: "number",
+    teleopCargoUpperNear: "number",
+    teleopCargoUpperRed: "number",
+    teleopPoints: "number",
+    totalPoints: "number"
+  }).partial(),
+  "2023": type4({
+    activationBonusAchieved: "boolean",
+    adjustPoints: "number",
+    autoBridgeState: "'NotLevel' | 'Level'",
+    autoChargeStationPoints: "number",
+    autoChargeStationRobot1: "'None' | 'Docked'",
+    autoChargeStationRobot2: "'None' | 'Docked'",
+    autoChargeStationRobot3: "'None' | 'Docked'",
+    autoCommunity: {
+      B: "('None' | 'Cube' | 'Cone')[]",
+      M: "('None' | 'Cube' | 'Cone')[]",
+      T: "('None' | 'Cube' | 'Cone')[]"
+    },
+    autoDocked: "boolean",
+    autoGamePieceCount: "number",
+    autoGamePiecePoints: "number",
+    autoMobilityPoints: "number",
+    autoPoints: "number",
+    coopGamePieceCount: "number",
+    coopertitionCriteriaMet: "boolean",
+    endGameBridgeState: "'NotLevel' | 'Level'",
+    endGameChargeStationPoints: "number",
+    endGameChargeStationRobot1: "'None' | 'Docked' | 'Parked'",
+    endGameChargeStationRobot2: "'None' | 'Docked' | 'Parked'",
+    endGameChargeStationRobot3: "'None' | 'Docked' | 'Parked'",
+    endGameParkPoints: "number",
+    foulCount: "number",
+    foulPoints: "number",
+    linkPoints: "number",
+    links: type4({
+      nodes: "number[]",
+      row: "'Bottom' | 'Mid' | 'Top'"
+    }).array(),
+    mobilityRobot1: "'Yes' | 'No'",
+    mobilityRobot2: "'Yes' | 'No'",
+    mobilityRobot3: "'Yes' | 'No'",
+    rp: "number",
+    sustainabilityBonusAchieved: "boolean",
+    techFoulCount: "number",
+    teleopCommunity: {
+      B: "('None' | 'Cube' | 'Cone')[]",
+      M: "('None' | 'Cube' | 'Cone')[]",
+      T: "('None' | 'Cube' | 'Cone')[]"
+    },
+    teleopGamePieceCount: "number",
+    teleopGamePiecePoints: "number",
+    teleopPoints: "number",
+    totalChargeStationPoints: "number",
+    totalPoints: "number"
+  }).partial(),
+  "2024": type4({
+    adjustPoints: "number",
+    autoAmpNoteCount: "number",
+    autoAmpNotePoints: "number",
+    autoLeavePoints: "number",
+    autoLineRobot1: "string",
+    autoLineRobot2: "string",
+    autoLineRobot3: "string",
+    autoPoints: "number",
+    autoSpeakerNoteCount: "number",
+    autoSpeakerNotePoints: "number",
+    autoTotalNotePoints: "number",
+    coopNotePlayed: "boolean",
+    coopertitionBonusAchieved: "boolean",
+    coopertitionCriteriaMet: "boolean",
+    endGameHarmonyPoints: "number",
+    endGameNoteInTrapPoints: "number",
+    endGameOnStagePoints: "number",
+    endGameParkPoints: "number",
+    endGameRobot1: "string",
+    endGameRobot2: "string",
+    endGameRobot3: "string",
+    endGameSpotLightBonusPoints: "number",
+    endGameTotalStagePoints: "number",
+    ensembleBonusAchieved: "boolean",
+    ensembleBonusOnStageRobotsThreshold: "number",
+    ensembleBonusStagePointsThreshold: "number",
+    foulCount: "number",
+    foulPoints: "number",
+    g206Penalty: "boolean",
+    g408Penalty: "boolean",
+    g424Penalty: "boolean",
+    melodyBonusAchieved: "boolean",
+    melodyBonusThreshold: "number",
+    melodyBonusThresholdCoop: "number",
+    melodyBonusThresholdNonCoop: "number",
+    micCenterStage: "boolean",
+    micStageLeft: "boolean",
+    micStageRight: "boolean",
+    rp: "number",
+    techFoulCount: "number",
+    teleopAmpNoteCount: "number",
+    teleopAmpNotePoints: "number",
+    teleopPoints: "number",
+    teleopSpeakerNoteAmplifiedCount: "number",
+    teleopSpeakerNoteAmplifiedPoints: "number",
+    teleopSpeakerNoteCount: "number",
+    teleopSpeakerNotePoints: "number",
+    teleopTotalNotePoints: "number",
+    totalPoints: "number",
+    trapCenterStage: "boolean",
+    trapStageLeft: "boolean",
+    trapStageRight: "boolean"
+  }).partial(),
+  "2025": type4({
+    adjustPoints: "number",
+    algaePoints: "number",
+    autoBonusAchieved: "boolean",
+    autoCoralCount: "number",
+    autoCoralPoints: "number",
+    autoLineRobot1: "'Yes' | 'No'",
+    autoLineRobot2: "'Yes' | 'No'",
+    autoLineRobot3: "'Yes' | 'No'",
+    autoMobilityPoints: "number",
+    autoPoints: "number",
+    autoReef: reef,
+    bargeBonusAchieved: "boolean",
+    coopertitionCriteriaMet: "boolean",
+    coralBonusAchieved: "boolean",
+    endGameBargePoints: "number",
+    endGameRobot1: "'None' | 'Parked' | 'ShallowCage' | 'DeepCage'",
+    endGameRobot2: "'None' | 'Parked' | 'ShallowCage' | 'DeepCage'",
+    endGameRobot3: "'None' | 'Parked' | 'ShallowCage' | 'DeepCage'",
+    foulCount: "number",
+    foulPoints: "number",
+    g206Penalty: "boolean",
+    g410Penalty: "boolean",
+    g418Penalty: "boolean",
+    g428Penalty: "boolean",
+    netAlgaeCount: "number",
+    rp: "number",
+    techFoulCount: "number",
+    teleopCoralCount: "number",
+    teleopCoralPoints: "number",
+    teleopPoints: "number",
+    teleopReef: reef,
+    totalPoints: "number",
+    wallAlgaeCount: "number"
+  }).partial(),
+  "2026": type4({
+    adjustPoints: "number",
+    autoTowerPoints: "number",
+    autoTowerRobot1: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    autoTowerRobot2: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    autoTowerRobot3: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    endGameTowerPoints: "number",
+    endGameTowerRobot1: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    endGameTowerRobot2: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    endGameTowerRobot3: "'Level1' | 'Level2' | 'Level3' | 'None'",
+    energizedAcheived: "boolean",
+    foulPoints: "number",
+    g206Penalty: "boolean",
+    hubScore: {
+      autoCount: "number",
+      autoPoints: "number",
+      endgameCount: "number",
+      endgamePoints: "number",
+      shift1Count: "number",
+      shift1Points: "number",
+      shift2Count: "number",
+      shift2Points: "number",
+      shift3Count: "number",
+      shift3Points: "number",
+      shift4Count: "number",
+      shift4Points: "number",
+      teleopCount: "number",
+      teleopPoints: "number",
+      totalCount: "number",
+      totalPoints: "number",
+      transitionCount: "number",
+      transitionPoints: "number"
+    },
+    majorFoulCount: "number",
+    minorFoulCount: "number",
+    rp: "number",
+    superchargedAcheived: "boolean",
+    totalAutoPoints: "number",
+    totalPoints: "number",
+    totalTeleopPoints: "number",
+    totalTowerPoints: "number",
+    traversalAchieved: "boolean"
+  }).partial()
+};
+var matchScoreBreakdownYearsMatches = {
+  "2015": type4({
+    red: matchScoreBreakdownYearsAlliances["2015"],
+    blue: matchScoreBreakdownYearsAlliances["2015"],
+    coopertition: "'None' | 'Unknown' | 'Stack'",
+    coopertition_points: "number",
+    yearOfCompetition: "2015"
+  }),
+  "2016": type4({
+    red: matchScoreBreakdownYearsAlliances["2016"],
+    blue: matchScoreBreakdownYearsAlliances["2016"],
+    yearOfCompetition: "2016"
+  }),
+  "2017": type4({
+    red: matchScoreBreakdownYearsAlliances["2017"],
+    blue: matchScoreBreakdownYearsAlliances["2017"],
+    yearOfCompetition: "2017"
+  }),
+  "2018": type4({
+    red: matchScoreBreakdownYearsAlliances["2018"],
+    blue: matchScoreBreakdownYearsAlliances["2018"],
+    yearOfCompetition: "2018"
+  }),
+  "2019": type4({
+    red: matchScoreBreakdownYearsAlliances["2019"],
+    blue: matchScoreBreakdownYearsAlliances["2019"],
+    yearOfCompetition: "2019"
+  }),
+  "2020": type4({
+    red: matchScoreBreakdownYearsAlliances["2020"],
+    blue: matchScoreBreakdownYearsAlliances["2020"],
+    yearOfCompetition: "2020"
+  }),
+  "2022": type4({
+    red: matchScoreBreakdownYearsAlliances["2022"],
+    blue: matchScoreBreakdownYearsAlliances["2022"],
+    yearOfCompetition: "2022"
+  }),
+  "2023": type4({
+    red: matchScoreBreakdownYearsAlliances["2023"],
+    blue: matchScoreBreakdownYearsAlliances["2023"],
+    yearOfCompetition: "2023"
+  }),
+  "2024": type4({
+    red: matchScoreBreakdownYearsAlliances["2024"],
+    blue: matchScoreBreakdownYearsAlliances["2024"],
+    yearOfCompetition: "2024"
+  }),
+  "2025": type4({
+    red: matchScoreBreakdownYearsAlliances["2025"],
+    blue: matchScoreBreakdownYearsAlliances["2025"],
+    yearOfCompetition: "2025"
+  }),
+  "2026": type4({
+    red: matchScoreBreakdownYearsAlliances["2026"],
+    blue: matchScoreBreakdownYearsAlliances["2026"],
+    yearOfCompetition: "2026"
+  })
+};
+var msb = matchScoreBreakdownYearsMatches;
+var Match_alliance = type4({
+  score: "number | null",
+  team_keys: "string[]",
+  surrogate_team_keys: "string[]",
+  dq_team_keys: "string[]"
+});
+var Match_Simple = type4({
+  key: "string",
+  comp_level: "'qm' | 'ef' | 'qf' | 'sf' |'f'",
+  set_number: "number",
+  match_number: "number",
+  alliances: type4({ red: Match_alliance, blue: Match_alliance }),
+  winning_alliance: "'red' | 'blue' | ''",
+  event_key: "string",
+  time: "number | null",
+  actual_time: "number | null",
+  predicted_time: "number | null"
+});
+var Match = Match_Simple.and({
+  videos: type4({ type: "string", key: "string" }).array(),
+  score_breakdown: msb["2015"].or(msb["2016"]).or(msb["2017"]).or(msb["2018"]).or(msb["2019"]).or(msb["2020"]).or(msb["2022"]).or(msb["2023"]).or(msb["2024"]).or(msb["2025"])
+});
+
+// src/types/endpoints/teams.ts
+import { type as type5 } from "arktype";
+var teamEndpoints = {
+  "/teams/{page_num}": {
+    schema: Team.array(),
+    arguments: type5(["number"])
+  },
+  "/teams/{page_num}/simple": {
+    schema: Team_Simple.array(),
+    arguments: type5(["number"])
+  },
+  "/teams/{page_num}/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["number"])
+  },
+  "/teams/{year}/{page_num}": {
+    schema: Team.array(),
+    arguments: type5(["number", "number"])
+  },
+  "/teams/{year}/{page_num}/simple": {
+    schema: Team_Simple.array(),
+    arguments: type5(["number", "number"])
+  },
+  "/teams/{year}/{page_num}/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["number", "number"])
+  },
+  "/team/{team_key}": {
+    schema: Team,
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/simple": {
+    schema: Team_Simple,
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/history": {
+    schema: type5({ events: Event.array(), awards: Award.array() }),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/years_participated": {
+    schema: type5("number[]"),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/districts": {
+    schema: District_List.array(),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/robots": {
+    schema: Team_Robot.array(),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/events": {
+    schema: Event.array(),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/events/simple": {
+    schema: Event_Simple.array(),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/events/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/events/{year}": {
+    schema: Event.array(),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/events/{year}/simple": {
+    schema: Event_Simple.array(),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/events/{year}/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/events/{year}/statuses": {
+    schema: type5({
+      "[string]": Team_Event_Status
+    }),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/event/{event_key}/matches": {
+    schema: Match.array(),
+    arguments: type5(["string", "string"]),
+    transformMatch: ({ key: eventKey }, schema) => {
+      if (eventKey && parseInt(eventKey.slice(0, 4)) && Array.isArray(schema) && schema.every((v) => v && typeof v === "object")) {
+        for (const member of schema) {
+          member["score_breakdown"]["yearOfCompetition"] = parseInt(
+            eventKey.slice(0, 4)
+          );
+        }
+      }
+      return schema;
+    }
+  },
+  "/team/{team_key}/event/{event_key}/matches/simple": {
+    schema: Match_Simple.array(),
+    arguments: type5(["string", "string"])
+  },
+  "/team/{team_key}/event/{event_key}/matches/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["string", "string"])
+  },
+  "/team/{team_key}/event/{event_key}/awards": {
+    schema: Award.array(),
+    arguments: type5(["string", "string"])
+  },
+  "/team/{team_key}/event/{event_key}/status": {
+    schema: type5(Team_Event_Status, "|", "null"),
+    arguments: type5(["string", "string"])
+  },
+  "/team/{team_key}/awards": {
+    schema: Award.array(),
+    arguments: type5(["string"])
+  },
+  "/team/{team_key}/awards/{year}": {
+    schema: Award.array(),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/matches/{year}": {
+    schema: Match.array(),
+    arguments: type5(["string", "number"]),
+    transformMatch: ({ year }, schema) => {
+      if (year && Array.isArray(schema) && schema.every((v) => v && typeof v === "object")) {
+        for (const member of schema) {
+          member["score_breakdown"]["yearOfCompetition"] = year;
+        }
+      }
+      return schema;
+    }
+  },
+  "/team/{team_key}/matches/{year}/simple": {
+    schema: Match_Simple.array(),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/matches/{year}/keys": {
+    schema: type5("string[]"),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/media/{year}": {
+    schema: Media.array(),
+    arguments: type5(["string", "number"])
+  },
+  "/team/{team_key}/media/tag/{media_tag}": {
+    schema: Media.array(),
+    arguments: type5(["string", "string"])
+  },
+  "/team/{team_key}/media/tag/{media_tag}/{year}": {
+    schema: Media.array(),
+    arguments: type5(["string", "string", "number"])
+  },
+  "/team/{team_key}/social_media": {
+    schema: Media.array(),
+    arguments: type5(["string"])
+  }
+};
+
+// src/types/schemas/status.ts
+import { type as type6 } from "arktype";
+var API_Status_App_Version = type6({
+  min_app_version: "number",
+  latest_app_version: "number"
+});
+
+// src/types/endpoints/status.ts
+import { type as type7 } from "arktype";
+var status = type7({
+  current_season: "number",
+  max_season: "number",
+  is_datafeed_down: "boolean",
+  down_events: "string[]",
+  ios: API_Status_App_Version,
+  android: API_Status_App_Version
+});
+var statusEndpoints = {
+  "/status": {
+    schema: status,
+    arguments: type7([])
+  }
+};
+
+// src/types/endpoints/events.ts
+import { type as type8 } from "arktype";
+var rankings = type8({
+  rankings: type8({
+    matches_played: "number",
+    qual_average: "number | null",
+    extra_stats: "number[]",
+    sort_orders: "number[] | null",
+    record: type8(WLT_Record, "|", "null"),
+    rank: "number",
+    dq: "number",
+    team_key: "string"
+  }).array(),
+  extra_stats_info: type8({
+    precision: "number",
+    name: "string"
+  }).array(),
+  sort_order_info: type8({
+    precision: "number",
+    name: "string"
+  }).array()
+});
+var eventPoints = type8({
+  points: type8({
+    "[string]": type8({
+      total: "number",
+      alliance_points: "number",
+      elim_points: "number",
+      award_points: "number",
+      qual_points: "number"
+    })
+  }),
+  "tiebreakers?": type8({
+    "[string]": type8({
+      highest_qual_scores: "number[]",
+      qual_points: "number"
+    }).partial()
+  })
+});
+var eventEndpoints = {
+  "/events/{year}": {
+    schema: Event.array(),
+    arguments: type8(["number"])
+  },
+  "/events/{year}/simple": {
+    schema: Event_Simple.array(),
+    arguments: type8(["number"])
+  },
+  "/events/{year}/keys": {
+    schema: type8("string[]"),
+    arguments: type8(["number"])
+  },
+  "/event/{event_key}": {
+    schema: Event,
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/simple": {
+    schema: Event_Simple,
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/alliances": {
+    schema: type8(Elimination_Alliance.array(), "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/insights": {
+    schema: type8(
+      {
+        qual: "unknown",
+        playoff: "unknown"
+      },
+      "|",
+      "null"
+    ),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/oprs": {
+    schema: type8({
+      oprs: { "[string]": "number" },
+      dprs: { "[string]": "number" },
+      ccwms: { "[string]": "number" }
+    }),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/coprs": {
+    schema: type8({ "[string]": { "[string]": "number" } }),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/predictions": {
+    schema: type8({ "[string]": "unknown" }, "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/rankings": {
+    schema: type8(rankings, "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/district_points": {
+    schema: type8(eventPoints, "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/regional_champs_pool_points": {
+    schema: type8(eventPoints, "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/advancement_points": {
+    schema: type8(eventPoints, "|", "null"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/teams": {
+    schema: Team.array(),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/teams/simple": {
+    schema: Team_Simple.array(),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/teams/keys": {
+    schema: type8("string[]"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/teams/statuses": {
+    schema: type8({ "[string]": Team_Event_Status }),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/matches": {
+    schema: Match.array(),
+    arguments: type8(["string"]),
+    transformMatch: ({ key }, schema) => {
+      if (key && parseInt(key.slice(0, 4)) && Array.isArray(schema) && schema.every((v) => v && typeof v === "object")) {
+        for (const member of schema) {
+          member["score_breakdown"]["yearOfCompetition"] = parseInt(
+            key.slice(0, 4)
+          );
+        }
+      }
+      return schema;
+    }
+  },
+  "/event/{event_key}/matches/simple": {
+    schema: Match_Simple.array(),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/matches/keys": {
+    schema: type8("string[]"),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/awards": {
+    schema: Award.array(),
+    arguments: type8(["string"])
+  },
+  "/event/{event_key}/team_media": {
+    schema: Media.array(),
+    arguments: type8(["string"])
+  }
+};
+
+// src/types/endpoints/matches.ts
+import { type as type9 } from "arktype";
+var matchEndpoints = {
+  "/match/{match_key}": {
+    schema: Match,
+    arguments: type9(["string"]),
+    transformMatch: ({ key: eventKey }, schema) => {
+      if (eventKey && parseInt(eventKey.slice(0, 4)) && typeof schema === "object" && schema) {
+        let newSchema = schema;
+        newSchema["score_breakdown"]["yearOfCompetition"] = parseInt(
+          eventKey.slice(0, 4)
+        );
+        return newSchema;
+      }
+      return schema;
+    }
+  },
+  "/match/{match_key}/simple": {
+    schema: Match_Simple,
+    arguments: type9(["string"])
+  }
+};
+
+// src/types/endpoints/districts.ts
+import { type as type10 } from "arktype";
+var districtEndpoints = {
+  "/districts/{year}": {
+    schema: District_List.array(),
+    arguments: type10(["number"])
+  },
+  "/district/{district_abbreviation}/history": {
+    schema: District_List.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/events": {
+    schema: Event.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/awards": {
+    schema: Award.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/events/simple": {
+    schema: Event_Simple.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/events/keys": {
+    schema: type10("string[]"),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/teams": {
+    schema: Team.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/teams/simple": {
+    schema: Team_Simple.array(),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/teams/keys": {
+    schema: type10("string[]"),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/rankings": {
+    schema: type10(District_Ranking.array(), "|", "null"),
+    arguments: type10(["string"])
+  },
+  "/district/{district_key}/advancement": {
+    schema: type10({ "[string]": District_Advancement }, "|", "null"),
+    arguments: type10(["string"])
+  }
+};
+
+// src/types/schemas/regionalAdvancements.ts
+import { type as type11 } from "arktype";
+var Regional_Advancement = type11({
+  cmp: "boolean",
+  cmp_status: "'NotInvited' | 'PreQualified' | 'EventQualified' | 'PoolQualified' | 'Declined'",
+  qualifying_event: "string?",
+  qualifying_award_name: "string?",
+  qualifying_pool_week: "number?"
+});
+var Regional_Ranking = type11({
+  team_key: "string",
+  rank: "number",
+  rookie_bonus: "number?",
+  point_total: "number",
+  single_event_bonus: "number?",
+  event_points: type11({
+    total: "number",
+    alliance_points: "number",
+    elim_points: "number",
+    award_points: "number",
+    event_key: "string",
+    qual_points: "number"
+  }).array()
+});
+
+// src/types/endpoints/regionalAdvancements.ts
+import { type as type12 } from "arktype";
+var regionalAdvancementEndpoints = {
+  "/regional_advancement/{year}": {
+    schema: type12({ "[string]": Regional_Advancement }),
+    arguments: type12(["number"])
+  },
+  "/regional_advancement/{year}/rankings": {
+    schema: Regional_Ranking.array(),
+    arguments: type12(["number"])
+  }
+};
+
+// src/types/schemas/insights.ts
+import { type as type13 } from "arktype";
+var LeaderboardInsights = type13({
+  data: {
+    rankings: type13({
+      value: "number",
+      keys: "string[]"
+    }).array(),
+    key_type: "'team' | 'event' | 'match'"
+  },
+  name: "string",
+  year: "number"
+});
+var NotablesInsight = type13({
+  data: {
+    entries: type13({
+      context: "string[]",
+      team_key: "string"
+    }).array()
+  },
+  name: "string",
+  year: "number"
+});
+
+// src/types/endpoints/insights.ts
+import { type as type14 } from "arktype";
+var insightEndpoints = {
+  "/insights/leaderboards/{year}": {
+    schema: LeaderboardInsights.array(),
+    arguments: type14(["number"])
+  },
+  "/insights/notables/{year}": {
+    schema: NotablesInsight.array(),
+    arguments: type14(["number"])
+  }
+};
+
+// src/types/endpoints/index.ts
+import { type as type15 } from "arktype";
+var Search_Index = type15({
+  teams: type15({
+    key: "string",
+    nickname: "string"
+  }).array(),
+  events: type15({
+    key: "string",
+    name: "string"
+  }).array()
+});
+var searchIndex = {
+  "/search_index": {
+    schema: Search_Index,
+    arguments: type15([])
+  }
+};
+var endpoints = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, statusEndpoints), teamEndpoints), eventEndpoints), matchEndpoints), districtEndpoints), regionalAdvancementEndpoints), insightEndpoints), searchIndex);
+
+// src/index.ts
 import { ArkErrors } from "arktype";
-/*
- * Creates a function that can call the TBA api.
- * @see https://www.thebluealliance.com/apidocs/v3
- * @param api_key The api key given to you from The Blue Alliance.
- * @returns A function that can request from any endpoint in the TBA api. Go to the TBA api docs to see more information on endpoints and arguments required.
- */
-export function createTBACaller(api_key) {
-    return async (endpoint, ...args) => await TBA(endpoint, api_key, ...args);
+function createTBACaller(api_key) {
+  return async (endpoint, ...args) => await TBA(endpoint, api_key, ...args);
 }
 async function TBA(endpoint, api_key, ...args) {
-    let numArg = -1;
-    // Fills all the arguments that are needed.
-    const filledEndpoint = endpoint.replace(/{(.+?)}/g, () => {
-        numArg++;
-        return args[numArg].toString();
-    });
-    const result = await tryCatch(fetch(`https://www.thebluealliance.com/api/v3${filledEndpoint}`, {
-        headers: {
-            "X-TBA-Auth-Key": api_key,
-        },
-    }));
-    if (result.error)
-        return {
-            data: null, error: result.error,
-        };
-    if (result.data.status !== 200)
-        return {
-            data: null,
-            error: new Error(`${result.data.status} - ${result.data.statusText}`),
-        };
-    const json = await tryCatch(result.data.json());
-    if (json.error)
-        return {
-            data: null,
-            error: new Error(`JSON didn't parse for endpoint ${endpoint}. Please contact the developers of the TBArequest package with this error: ${json.error.message}`),
-        };
-    if ("transformMatch" in endpoints[endpoint]) {
-        let data;
-        switch (endpoint) {
-            case "/event/{event_key}/matches":
-            case "/match/{match_key}": {
-                data = { key: args[0] };
-                break;
-            }
-            case "/team/{team_key}/event/{event_key}/matches": {
-                data = { key: args[1] };
-                break;
-            }
-            case "/team/{team_key}/matches/{year}": {
-                data = { year: args[1] };
-                break;
-            }
-            default: {
-                data = {};
-            }
-        }
-        json.data = endpoints[endpoint].transformMatch(data, json.data);
+  let numArg = -1;
+  const filledEndpoint = endpoint.replace(/{(.+?)}/g, () => {
+    numArg++;
+    return args[numArg].toString();
+  });
+  const result = await tryCatch(
+    fetch(`https://www.thebluealliance.com/api/v3${filledEndpoint}`, {
+      headers: {
+        "X-TBA-Auth-Key": api_key
+      }
+    })
+  );
+  if (result.error)
+    return {
+      data: null,
+      error: result.error
+    };
+  if (result.data.status !== 200)
+    return {
+      data: null,
+      error: new Error(`${result.data.status} - ${result.data.statusText}`)
+    };
+  const json = await tryCatch(result.data.json());
+  if (json.error)
+    return {
+      data: null,
+      error: new Error(
+        `JSON didn't parse for endpoint ${endpoint}. Please contact the developers of the TBArequest package with this error: ${json.error.message}`
+      )
+    };
+  if ("transformMatch" in endpoints[endpoint]) {
+    let data;
+    switch (endpoint) {
+      case "/event/{event_key}/matches":
+      case "/match/{match_key}": {
+        data = { key: args[0] };
+        break;
+      }
+      case "/team/{team_key}/event/{event_key}/matches": {
+        data = { key: args[1] };
+        break;
+      }
+      case "/team/{team_key}/matches/{year}": {
+        data = { year: args[1] };
+        break;
+      }
+      default: {
+        data = {};
+      }
     }
-    let schema = endpoints[endpoint].schema(json.data);
-    if (schema instanceof ArkErrors)
-        return {
-            data: null,
-            error: new Error(`Schema for endpoint ${endpoint} didn't work. Please contact the developers of the TBArequest package with this error: ${schema}`),
-        };
-    return { data: schema, error: null };
+    json.data = endpoints[endpoint].transformMatch(
+      data,
+      json.data
+    );
+  }
+  let schema = endpoints[endpoint].schema(json.data);
+  if (schema instanceof ArkErrors)
+    return {
+      data: null,
+      error: new Error(
+        `Schema for endpoint ${endpoint} didn't work. Please contact the developers of the TBArequest package with this error: ${schema}`
+      )
+    };
+  return { data: schema, error: null };
 }
+export {
+  createTBACaller
+};