hevy-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,2107 @@
+// Generated with tsup
+// https://github.com/egoist/tsup
+
+// src/index.ts
+import "@dotenvx/dotenvx/config";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/folders.ts
+import { z } from "zod";
+function registerFolderTools(server2, hevyClient2) {
+  server2.tool(
+    "get-routine-folders",
+    {
+      page: z.number().int().gte(1).default(1),
+      pageSize: z.number().int().gte(1).lte(10).default(5)
+    },
+    async ({ page, pageSize }) => {
+      try {
+        const data = await hevyClient2.v1.routine_folders.get({
+          queryParameters: {
+            page,
+            pageSize
+          }
+        });
+        const folders = data?.routineFolders?.map((folder) => formatRoutineFolder(folder)) || [];
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(folders, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error fetching routine folders:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching routine folders: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get-routine-folder",
+    {
+      folderId: z.number().int()
+    },
+    async ({ folderId }) => {
+      try {
+        const data = await hevyClient2.v1.routine_folders.byFolderId(folderId.toString()).get();
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Routine folder with ID ${folderId} not found`
+              }
+            ]
+          };
+        }
+        const folder = formatRoutineFolder(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(folder, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(`Error fetching routine folder ${folderId}:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching routine folder: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "create-routine-folder",
+    {
+      title: z.string().min(1)
+    },
+    async ({ title }) => {
+      try {
+        const data = await hevyClient2.v1.routine_folders.post({
+          routineFolder: {
+            title
+          }
+        });
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Failed to create routine folder"
+              }
+            ]
+          };
+        }
+        const folder = formatRoutineFolder(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Routine folder created successfully:
+${JSON.stringify(folder, null, 2)}`
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error creating routine folder:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating routine folder: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function formatRoutineFolder(folder) {
+  return {
+    id: folder.id,
+    title: folder.title,
+    index: folder.index,
+    createdAt: folder.createdAt,
+    updatedAt: folder.updatedAt
+  };
+}
+
+// src/tools/routines.ts
+import { z as z2 } from "zod";
+function registerRoutineTools(server2, hevyClient2) {
+  server2.tool(
+    "get-routines",
+    {
+      page: z2.number().int().gte(1).default(1),
+      pageSize: z2.number().int().gte(1).lte(10).default(5)
+    },
+    async ({ page, pageSize }) => {
+      try {
+        const data = await hevyClient2.v1.routines.get({
+          queryParameters: {
+            page,
+            pageSize
+          }
+        });
+        const routines = data?.routines?.map((routine) => formatRoutine(routine)) || [];
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(routines, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error fetching routines:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching routines: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get-routine",
+    {
+      routineId: z2.string().min(1)
+    },
+    async ({ routineId }) => {
+      try {
+        const response = await hevyClient2.v1.routines.get();
+        const data = response?.routines?.find(
+          (routine2) => routine2.id === routineId
+        );
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Routine with ID ${routineId} not found`
+              }
+            ]
+          };
+        }
+        const routine = formatRoutine(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(routine, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(`Error fetching routine ${routineId}:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching routine: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "create-routine",
+    {
+      title: z2.string().min(1),
+      folderId: z2.number().nullable().optional(),
+      notes: z2.string().optional(),
+      exercises: z2.array(
+        z2.object({
+          exerciseTemplateId: z2.string().min(1),
+          supersetId: z2.number().nullable().optional(),
+          restSeconds: z2.number().int().min(0).optional(),
+          notes: z2.string().optional(),
+          sets: z2.array(
+            z2.object({
+              type: z2.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z2.number().optional(),
+              reps: z2.number().int().optional(),
+              distanceMeters: z2.number().int().optional(),
+              durationSeconds: z2.number().int().optional(),
+              customMetric: z2.number().optional()
+            })
+          )
+        })
+      )
+    },
+    async ({ title, folderId, notes, exercises }) => {
+      try {
+        const data = await hevyClient2.v1.routines.post({
+          routine: {
+            title,
+            folderId: folderId || null,
+            notes: notes || "",
+            exercises: exercises.map((exercise) => ({
+              exerciseTemplateId: exercise.exerciseTemplateId,
+              supersetId: exercise.supersetId || null,
+              restSeconds: exercise.restSeconds || null,
+              notes: exercise.notes || null,
+              sets: exercise.sets.map((set) => ({
+                type: set.type,
+                weightKg: set.weightKg || null,
+                reps: set.reps || null,
+                distanceMeters: set.distanceMeters || null,
+                durationSeconds: set.durationSeconds || null,
+                customMetric: set.customMetric || null
+              }))
+            }))
+          }
+        });
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Failed to create routine"
+              }
+            ]
+          };
+        }
+        const routine = formatRoutine(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Routine created successfully:
+${JSON.stringify(routine, null, 2)}`
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error creating routine:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating routine: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "update-routine",
+    {
+      routineId: z2.string().min(1),
+      title: z2.string().min(1),
+      notes: z2.string().optional(),
+      exercises: z2.array(
+        z2.object({
+          exerciseTemplateId: z2.string().min(1),
+          supersetId: z2.number().nullable().optional(),
+          restSeconds: z2.number().int().min(0).optional(),
+          notes: z2.string().optional(),
+          sets: z2.array(
+            z2.object({
+              type: z2.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z2.number().optional(),
+              reps: z2.number().int().optional(),
+              distanceMeters: z2.number().int().optional(),
+              durationSeconds: z2.number().int().optional(),
+              customMetric: z2.number().optional()
+            })
+          )
+        })
+      )
+    },
+    async ({ routineId, title, notes, exercises }) => {
+      try {
+        const data = await hevyClient2.v1.routines.byRoutineId(routineId).put({
+          routine: {
+            title,
+            notes: notes || null,
+            exercises: exercises.map((exercise) => ({
+              exerciseTemplateId: exercise.exerciseTemplateId,
+              supersetId: exercise.supersetId || null,
+              restSeconds: exercise.restSeconds || null,
+              notes: exercise.notes || null,
+              sets: exercise.sets.map((set) => ({
+                type: set.type,
+                weightKg: set.weightKg || null,
+                reps: set.reps || null,
+                distanceMeters: set.distanceMeters || null,
+                durationSeconds: set.durationSeconds || null,
+                customMetric: set.customMetric || null
+              }))
+            }))
+          }
+        });
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Failed to update routine with ID ${routineId}`
+              }
+            ]
+          };
+        }
+        const routine = formatRoutine(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Routine updated successfully:
+${JSON.stringify(routine, null, 2)}`
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(`Error updating routine ${routineId}:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error updating routine: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function formatRoutine(routine) {
+  return {
+    id: routine.id,
+    title: routine.title,
+    folderId: routine.folderId,
+    createdAt: routine.createdAt,
+    updatedAt: routine.updatedAt,
+    exercises: routine.exercises?.map((exercise) => {
+      return {
+        name: exercise.title,
+        index: exercise.index,
+        exerciseTemplateId: exercise.exerciseTemplateId,
+        notes: exercise.notes,
+        supersetId: exercise.supersetsId,
+        sets: exercise.sets?.map((set) => ({
+          index: set.index,
+          type: set.type,
+          weight: set.weightKg,
+          reps: set.reps,
+          distance: set.distanceMeters,
+          duration: set.durationSeconds,
+          customMetric: set.customMetric
+        }))
+      };
+    })
+  };
+}
+
+// src/tools/templates.ts
+import { z as z3 } from "zod";
+function registerTemplateTools(server2, hevyClient2) {
+  server2.tool(
+    "get-exercise-templates",
+    {
+      page: z3.number().int().gte(1).default(1),
+      pageSize: z3.number().int().gte(1).lte(100).default(20)
+    },
+    async ({ page, pageSize }) => {
+      try {
+        const data = await hevyClient2.v1.exercise_templates.get({
+          queryParameters: {
+            page,
+            pageSize
+          }
+        });
+        const templates = data?.exerciseTemplates?.map(
+          (template) => formatExerciseTemplate(template)
+        ) || [];
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(templates, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error fetching exercise templates:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching exercise templates: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get-exercise-template",
+    {
+      exerciseTemplateId: z3.string().min(1)
+    },
+    async ({ exerciseTemplateId }) => {
+      try {
+        const data = await hevyClient2.v1.exercise_templates.byExerciseTemplateId(exerciseTemplateId).get();
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Exercise template with ID ${exerciseTemplateId} not found`
+              }
+            ]
+          };
+        }
+        const template = formatExerciseTemplate(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(template, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(
+          `Error fetching exercise template ${exerciseTemplateId}:`,
+          error
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching exercise template: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function formatExerciseTemplate(template) {
+  return {
+    id: template.id,
+    title: template.title,
+    type: template.type,
+    primaryMuscleGroup: template.primaryMuscleGroup,
+    secondaryMuscleGroups: template.secondaryMuscleGroups,
+    isCustom: template.isCustom
+  };
+}
+
+// src/tools/workouts.ts
+import { z as z4 } from "zod";
+function registerWorkoutTools(server2, hevyClient2) {
+  server2.tool(
+    "get-workouts",
+    {
+      page: z4.number().int().gte(1).default(1),
+      pageSize: z4.number().int().gte(1).lte(10).default(5)
+    },
+    async ({ page, pageSize }, extra) => {
+      try {
+        const data = await hevyClient2.v1.workouts.get({
+          queryParameters: {
+            page,
+            pageSize
+          }
+        });
+        const workouts = data?.workouts?.map((workout) => formatWorkout(workout)) || [];
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(workouts, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error fetching workouts:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching workouts: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get-workout",
+    {
+      workoutId: z4.string().min(1)
+    },
+    async ({ workoutId }, extra) => {
+      try {
+        const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).get();
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Workout with ID ${workoutId} not found`
+              }
+            ]
+          };
+        }
+        const workout = formatWorkout(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(workout, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(`Error fetching workout ${workoutId}:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching workout: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool("get-workout-count", {}, async (_, extra) => {
+    try {
+      const data = await hevyClient2.v1.workouts.count.get();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Total workouts: ${data ? data.count || 0 : 0}`
+          }
+        ]
+      };
+    } catch (error) {
+      console.error("Error fetching workout count:", error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error fetching workout count: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ]
+      };
+    }
+  });
+  server2.tool(
+    "get-workout-events",
+    {
+      page: z4.number().int().gte(1).default(1),
+      pageSize: z4.number().int().gte(1).lte(10).default(5),
+      since: z4.string().default("1970-01-01T00:00:00Z")
+    },
+    async ({ page, pageSize, since }, extra) => {
+      try {
+        const data = await hevyClient2.v1.workouts.events.get({
+          queryParameters: {
+            page,
+            pageSize,
+            since
+          }
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(data?.events || [], null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error fetching workout events:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching workout events: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "create-workout",
+    {
+      title: z4.string().min(1),
+      description: z4.string().optional().nullable(),
+      startTime: z4.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      endTime: z4.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      isPrivate: z4.boolean().default(false),
+      exercises: z4.array(
+        z4.object({
+          exerciseTemplateId: z4.string().min(1),
+          supersetId: z4.number().nullable().optional(),
+          notes: z4.string().optional().nullable(),
+          sets: z4.array(
+            z4.object({
+              type: z4.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z4.number().optional().nullable(),
+              reps: z4.number().int().optional().nullable(),
+              distanceMeters: z4.number().int().optional().nullable(),
+              durationSeconds: z4.number().int().optional().nullable(),
+              rpe: z4.number().optional().nullable(),
+              customMetric: z4.number().optional().nullable()
+            })
+          )
+        })
+      )
+    },
+    async ({ title, description, startTime, endTime, isPrivate, exercises }, extra) => {
+      try {
+        const requestBody = {
+          workout: {
+            title,
+            description: description || null,
+            startTime,
+            endTime,
+            isPrivate,
+            exercises: exercises.map((exercise) => ({
+              exerciseTemplateId: exercise.exerciseTemplateId,
+              supersetId: exercise.supersetId || null,
+              notes: exercise.notes || null,
+              sets: exercise.sets.map((set) => ({
+                type: set.type,
+                weightKg: set.weightKg || null,
+                reps: set.reps || null,
+                distanceMeters: set.distanceMeters || null,
+                durationSeconds: set.durationSeconds || null,
+                rpe: set.rpe || null,
+                customMetric: set.customMetric || null
+              }))
+            }))
+          }
+        };
+        const data = await hevyClient2.v1.workouts.post(requestBody);
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Failed to create workout"
+              }
+            ]
+          };
+        }
+        const workout = formatWorkout(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Workout created successfully:
+${JSON.stringify(workout, null, 2)}`
+            }
+          ]
+        };
+      } catch (error) {
+        console.error("Error creating workout:", error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error creating workout: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server2.tool(
+    "update-workout",
+    {
+      workoutId: z4.string().min(1),
+      title: z4.string().min(1),
+      description: z4.string().optional().nullable(),
+      startTime: z4.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      endTime: z4.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      isPrivate: z4.boolean().default(false),
+      exercises: z4.array(
+        z4.object({
+          exerciseTemplateId: z4.string().min(1),
+          supersetId: z4.number().nullable().optional(),
+          notes: z4.string().optional().nullable(),
+          sets: z4.array(
+            z4.object({
+              type: z4.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z4.number().optional().nullable(),
+              reps: z4.number().int().optional().nullable(),
+              distanceMeters: z4.number().int().optional().nullable(),
+              durationSeconds: z4.number().int().optional().nullable(),
+              rpe: z4.number().optional().nullable(),
+              customMetric: z4.number().optional().nullable()
+            })
+          )
+        })
+      )
+    },
+    async ({
+      workoutId,
+      title,
+      description,
+      startTime,
+      endTime,
+      isPrivate,
+      exercises
+    }, extra) => {
+      try {
+        const requestBody = {
+          workout: {
+            title,
+            description: description || null,
+            startTime,
+            endTime,
+            isPrivate,
+            exercises: exercises.map((exercise) => ({
+              exerciseTemplateId: exercise.exerciseTemplateId,
+              supersetId: exercise.supersetId || null,
+              notes: exercise.notes || null,
+              sets: exercise.sets.map((set) => ({
+                type: set.type,
+                weightKg: set.weightKg || null,
+                reps: set.reps || null,
+                distanceMeters: set.distanceMeters || null,
+                durationSeconds: set.durationSeconds || null,
+                rpe: set.rpe || null,
+                customMetric: set.customMetric || null
+              }))
+            }))
+          }
+        };
+        const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).put(requestBody);
+        if (!data) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Failed to update workout with ID ${workoutId}`
+              }
+            ]
+          };
+        }
+        const workout = formatWorkout(data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Workout updated successfully:
+${JSON.stringify(workout, null, 2)}`
+            }
+          ]
+        };
+      } catch (error) {
+        console.error(`Error updating workout ${workoutId}:`, error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error updating workout: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function formatWorkout(workout) {
+  return {
+    id: workout.id,
+    date: workout.createdAt,
+    name: workout.title,
+    description: workout.description,
+    duration: calculateDuration(workout.startTime || "", workout.endTime || ""),
+    exercises: workout.exercises?.map((exercise) => {
+      return {
+        name: exercise.title,
+        notes: exercise.notes,
+        sets: exercise.sets?.map((set) => ({
+          type: set.type,
+          weight: set.weightKg,
+          reps: set.reps,
+          distance: set.distanceMeters,
+          duration: set.durationSeconds,
+          rpe: set.rpe,
+          customMetric: set.customMetric
+        }))
+      };
+    })
+  };
+}
+function calculateDuration(startTime, endTime) {
+  try {
+    if (!startTime || !endTime) return "Unknown duration";
+    const start = typeof startTime === "number" ? startTime : new Date(startTime).getTime();
+    const end = typeof endTime === "number" ? endTime : new Date(endTime).getTime();
+    const durationMinutes = Math.round((end - start) / 6e4);
+    return `${durationMinutes} minutes`;
+  } catch (error) {
+    return "Unknown duration";
+  }
+}
+
+// src/utils/hevyClient.ts
+import { FetchRequestAdapter } from "@microsoft/kiota-http-fetchlibrary";
+
+// src/generated/client/models/index.ts
+function createDeletedWorkoutFromDiscriminatorValue(parseNode) {
+  return deserializeIntoDeletedWorkout;
+}
+function createExerciseTemplateFromDiscriminatorValue(parseNode) {
+  return deserializeIntoExerciseTemplate;
+}
+function createPaginatedWorkoutEventsFromDiscriminatorValue(parseNode) {
+  return deserializeIntoPaginatedWorkoutEvents;
+}
+function createRoutine_exercises_setsFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine_exercises_sets;
+}
+function createRoutine_exercisesFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine_exercises;
+}
+function createRoutineFolderFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutineFolder;
+}
+function createRoutineFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine;
+}
+function createUpdatedWorkoutFromDiscriminatorValue(parseNode) {
+  return deserializeIntoUpdatedWorkout;
+}
+function createWorkout_exercises_setsFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkout_exercises_sets;
+}
+function createWorkout_exercisesFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkout_exercises;
+}
+function createWorkoutFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkout;
+}
+function deserializeIntoDeletedWorkout(deletedWorkout = {}) {
+  return {
+    "deleted_at": (n) => {
+      deletedWorkout.deletedAt = n.getStringValue();
+    },
+    "id": (n) => {
+      deletedWorkout.id = n.getStringValue();
+    },
+    "type": (n) => {
+      deletedWorkout.type = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoExerciseTemplate(exerciseTemplate = {}) {
+  return {
+    "id": (n) => {
+      exerciseTemplate.id = n.getStringValue();
+    },
+    "is_custom": (n) => {
+      exerciseTemplate.isCustom = n.getBooleanValue();
+    },
+    "primary_muscle_group": (n) => {
+      exerciseTemplate.primaryMuscleGroup = n.getStringValue();
+    },
+    "secondary_muscle_groups": (n) => {
+      exerciseTemplate.secondaryMuscleGroups = n.getCollectionOfPrimitiveValues();
+    },
+    "title": (n) => {
+      exerciseTemplate.title = n.getStringValue();
+    },
+    "type": (n) => {
+      exerciseTemplate.type = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoPaginatedWorkoutEvents(paginatedWorkoutEvents = {}) {
+  return {
+    "events": (n) => {
+      paginatedWorkoutEvents.events = n.getCollectionOfObjectValues(createDeletedWorkoutFromDiscriminatorValue) ?? n.getCollectionOfObjectValues(createUpdatedWorkoutFromDiscriminatorValue);
+    },
+    "page": (n) => {
+      paginatedWorkoutEvents.page = n.getNumberValue();
+    },
+    "page_count": (n) => {
+      paginatedWorkoutEvents.pageCount = n.getNumberValue();
+    }
+  };
+}
+function deserializeIntoRoutine(routine = {}) {
+  return {
+    "created_at": (n) => {
+      routine.createdAt = n.getStringValue();
+    },
+    "exercises": (n) => {
+      routine.exercises = n.getCollectionOfObjectValues(createRoutine_exercisesFromDiscriminatorValue);
+    },
+    "folder_id": (n) => {
+      routine.folderId = n.getNumberValue();
+    },
+    "id": (n) => {
+      routine.id = n.getStringValue();
+    },
+    "title": (n) => {
+      routine.title = n.getStringValue();
+    },
+    "updated_at": (n) => {
+      routine.updatedAt = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine_exercises(routine_exercises = {}) {
+  return {
+    "exercise_template_id": (n) => {
+      routine_exercises.exerciseTemplateId = n.getStringValue();
+    },
+    "index": (n) => {
+      routine_exercises.index = n.getNumberValue();
+    },
+    "notes": (n) => {
+      routine_exercises.notes = n.getStringValue();
+    },
+    "sets": (n) => {
+      routine_exercises.sets = n.getCollectionOfObjectValues(createRoutine_exercises_setsFromDiscriminatorValue);
+    },
+    "supersets_id": (n) => {
+      routine_exercises.supersetsId = n.getNumberValue();
+    },
+    "title": (n) => {
+      routine_exercises.title = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine_exercises_sets(routine_exercises_sets = {}) {
+  return {
+    "custom_metric": (n) => {
+      routine_exercises_sets.customMetric = n.getNumberValue();
+    },
+    "distance_meters": (n) => {
+      routine_exercises_sets.distanceMeters = n.getNumberValue();
+    },
+    "duration_seconds": (n) => {
+      routine_exercises_sets.durationSeconds = n.getNumberValue();
+    },
+    "index": (n) => {
+      routine_exercises_sets.index = n.getNumberValue();
+    },
+    "reps": (n) => {
+      routine_exercises_sets.reps = n.getNumberValue();
+    },
+    "rpe": (n) => {
+      routine_exercises_sets.rpe = n.getNumberValue();
+    },
+    "type": (n) => {
+      routine_exercises_sets.type = n.getStringValue();
+    },
+    "weight_kg": (n) => {
+      routine_exercises_sets.weightKg = n.getNumberValue();
+    }
+  };
+}
+function deserializeIntoRoutineFolder(routineFolder = {}) {
+  return {
+    "created_at": (n) => {
+      routineFolder.createdAt = n.getStringValue();
+    },
+    "id": (n) => {
+      routineFolder.id = n.getNumberValue();
+    },
+    "index": (n) => {
+      routineFolder.index = n.getNumberValue();
+    },
+    "title": (n) => {
+      routineFolder.title = n.getStringValue();
+    },
+    "updated_at": (n) => {
+      routineFolder.updatedAt = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoUpdatedWorkout(updatedWorkout = {}) {
+  return {
+    "type": (n) => {
+      updatedWorkout.type = n.getStringValue();
+    },
+    "workout": (n) => {
+      updatedWorkout.workout = n.getObjectValue(createWorkoutFromDiscriminatorValue);
+    }
+  };
+}
+function deserializeIntoWorkout(workout = {}) {
+  return {
+    "created_at": (n) => {
+      workout.createdAt = n.getStringValue();
+    },
+    "description": (n) => {
+      workout.description = n.getStringValue();
+    },
+    "end_time": (n) => {
+      workout.endTime = n.getNumberValue();
+    },
+    "exercises": (n) => {
+      workout.exercises = n.getCollectionOfObjectValues(createWorkout_exercisesFromDiscriminatorValue);
+    },
+    "id": (n) => {
+      workout.id = n.getStringValue();
+    },
+    "start_time": (n) => {
+      workout.startTime = n.getNumberValue();
+    },
+    "title": (n) => {
+      workout.title = n.getStringValue();
+    },
+    "updated_at": (n) => {
+      workout.updatedAt = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoWorkout_exercises(workout_exercises = {}) {
+  return {
+    "exercise_template_id": (n) => {
+      workout_exercises.exerciseTemplateId = n.getStringValue();
+    },
+    "index": (n) => {
+      workout_exercises.index = n.getNumberValue();
+    },
+    "notes": (n) => {
+      workout_exercises.notes = n.getStringValue();
+    },
+    "sets": (n) => {
+      workout_exercises.sets = n.getCollectionOfObjectValues(createWorkout_exercises_setsFromDiscriminatorValue);
+    },
+    "supersets_id": (n) => {
+      workout_exercises.supersetsId = n.getNumberValue();
+    },
+    "title": (n) => {
+      workout_exercises.title = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoWorkout_exercises_sets(workout_exercises_sets = {}) {
+  return {
+    "custom_metric": (n) => {
+      workout_exercises_sets.customMetric = n.getNumberValue();
+    },
+    "distance_meters": (n) => {
+      workout_exercises_sets.distanceMeters = n.getNumberValue();
+    },
+    "duration_seconds": (n) => {
+      workout_exercises_sets.durationSeconds = n.getNumberValue();
+    },
+    "index": (n) => {
+      workout_exercises_sets.index = n.getNumberValue();
+    },
+    "reps": (n) => {
+      workout_exercises_sets.reps = n.getNumberValue();
+    },
+    "rpe": (n) => {
+      workout_exercises_sets.rpe = n.getNumberValue();
+    },
+    "type": (n) => {
+      workout_exercises_sets.type = n.getStringValue();
+    },
+    "weight_kg": (n) => {
+      workout_exercises_sets.weightKg = n.getNumberValue();
+    }
+  };
+}
+function serializePostRoutineFolderRequestBody(writer, postRoutineFolderRequestBody = {}) {
+  if (postRoutineFolderRequestBody) {
+    writer.writeObjectValue("routine_folder", postRoutineFolderRequestBody.routineFolder, serializePostRoutineFolderRequestBody_routine_folder);
+    writer.writeAdditionalData(postRoutineFolderRequestBody.additionalData);
+  }
+}
+function serializePostRoutineFolderRequestBody_routine_folder(writer, postRoutineFolderRequestBody_routine_folder = {}) {
+  if (postRoutineFolderRequestBody_routine_folder) {
+    writer.writeStringValue("title", postRoutineFolderRequestBody_routine_folder.title);
+    writer.writeAdditionalData(postRoutineFolderRequestBody_routine_folder.additionalData);
+  }
+}
+function serializePostRoutinesRequestBody(writer, postRoutinesRequestBody = {}) {
+  if (postRoutinesRequestBody) {
+    writer.writeObjectValue("routine", postRoutinesRequestBody.routine, serializePostRoutinesRequestBody_routine);
+    writer.writeAdditionalData(postRoutinesRequestBody.additionalData);
+  }
+}
+function serializePostRoutinesRequestBody_routine(writer, postRoutinesRequestBody_routine = {}) {
+  if (postRoutinesRequestBody_routine) {
+    writer.writeCollectionOfObjectValues("exercises", postRoutinesRequestBody_routine.exercises, serializePostRoutinesRequestExercise);
+    writer.writeNumberValue("folder_id", postRoutinesRequestBody_routine.folderId);
+    writer.writeStringValue("notes", postRoutinesRequestBody_routine.notes);
+    writer.writeStringValue("title", postRoutinesRequestBody_routine.title);
+    writer.writeAdditionalData(postRoutinesRequestBody_routine.additionalData);
+  }
+}
+function serializePostRoutinesRequestExercise(writer, postRoutinesRequestExercise = {}) {
+  if (postRoutinesRequestExercise) {
+    writer.writeStringValue("exercise_template_id", postRoutinesRequestExercise.exerciseTemplateId);
+    writer.writeStringValue("notes", postRoutinesRequestExercise.notes);
+    writer.writeNumberValue("rest_seconds", postRoutinesRequestExercise.restSeconds);
+    writer.writeCollectionOfObjectValues("sets", postRoutinesRequestExercise.sets, serializePostRoutinesRequestSet);
+    writer.writeNumberValue("superset_id", postRoutinesRequestExercise.supersetId);
+    writer.writeAdditionalData(postRoutinesRequestExercise.additionalData);
+  }
+}
+function serializePostRoutinesRequestSet(writer, postRoutinesRequestSet = {}) {
+  if (postRoutinesRequestSet) {
+    writer.writeNumberValue("custom_metric", postRoutinesRequestSet.customMetric);
+    writer.writeNumberValue("distance_meters", postRoutinesRequestSet.distanceMeters);
+    writer.writeNumberValue("duration_seconds", postRoutinesRequestSet.durationSeconds);
+    writer.writeNumberValue("reps", postRoutinesRequestSet.reps);
+    writer.writeEnumValue("type", postRoutinesRequestSet.type);
+    writer.writeNumberValue("weight_kg", postRoutinesRequestSet.weightKg);
+    writer.writeAdditionalData(postRoutinesRequestSet.additionalData);
+  }
+}
+function serializePostWorkoutsRequestBody(writer, postWorkoutsRequestBody = {}) {
+  if (postWorkoutsRequestBody) {
+    writer.writeObjectValue("workout", postWorkoutsRequestBody.workout, serializePostWorkoutsRequestBody_workout);
+    writer.writeAdditionalData(postWorkoutsRequestBody.additionalData);
+  }
+}
+function serializePostWorkoutsRequestBody_workout(writer, postWorkoutsRequestBody_workout = {}) {
+  if (postWorkoutsRequestBody_workout) {
+    writer.writeStringValue("description", postWorkoutsRequestBody_workout.description);
+    writer.writeStringValue("end_time", postWorkoutsRequestBody_workout.endTime);
+    writer.writeCollectionOfObjectValues("exercises", postWorkoutsRequestBody_workout.exercises, serializePostWorkoutsRequestExercise);
+    writer.writeBooleanValue("is_private", postWorkoutsRequestBody_workout.isPrivate);
+    writer.writeStringValue("start_time", postWorkoutsRequestBody_workout.startTime);
+    writer.writeStringValue("title", postWorkoutsRequestBody_workout.title);
+    writer.writeAdditionalData(postWorkoutsRequestBody_workout.additionalData);
+  }
+}
+function serializePostWorkoutsRequestExercise(writer, postWorkoutsRequestExercise = {}) {
+  if (postWorkoutsRequestExercise) {
+    writer.writeStringValue("exercise_template_id", postWorkoutsRequestExercise.exerciseTemplateId);
+    writer.writeStringValue("notes", postWorkoutsRequestExercise.notes);
+    writer.writeCollectionOfObjectValues("sets", postWorkoutsRequestExercise.sets, serializePostWorkoutsRequestSet);
+    writer.writeNumberValue("superset_id", postWorkoutsRequestExercise.supersetId);
+    writer.writeAdditionalData(postWorkoutsRequestExercise.additionalData);
+  }
+}
+function serializePostWorkoutsRequestSet(writer, postWorkoutsRequestSet = {}) {
+  if (postWorkoutsRequestSet) {
+    writer.writeNumberValue("custom_metric", postWorkoutsRequestSet.customMetric);
+    writer.writeNumberValue("distance_meters", postWorkoutsRequestSet.distanceMeters);
+    writer.writeNumberValue("duration_seconds", postWorkoutsRequestSet.durationSeconds);
+    writer.writeNumberValue("reps", postWorkoutsRequestSet.reps);
+    writer.writeNumberValue("rpe", postWorkoutsRequestSet.rpe);
+    writer.writeEnumValue("type", postWorkoutsRequestSet.type);
+    writer.writeNumberValue("weight_kg", postWorkoutsRequestSet.weightKg);
+    writer.writeAdditionalData(postWorkoutsRequestSet.additionalData);
+  }
+}
+function serializePutRoutinesRequestBody(writer, putRoutinesRequestBody = {}) {
+  if (putRoutinesRequestBody) {
+    writer.writeObjectValue("routine", putRoutinesRequestBody.routine, serializePutRoutinesRequestBody_routine);
+    writer.writeAdditionalData(putRoutinesRequestBody.additionalData);
+  }
+}
+function serializePutRoutinesRequestBody_routine(writer, putRoutinesRequestBody_routine = {}) {
+  if (putRoutinesRequestBody_routine) {
+    writer.writeCollectionOfObjectValues("exercises", putRoutinesRequestBody_routine.exercises, serializePutRoutinesRequestExercise);
+    writer.writeStringValue("notes", putRoutinesRequestBody_routine.notes);
+    writer.writeStringValue("title", putRoutinesRequestBody_routine.title);
+    writer.writeAdditionalData(putRoutinesRequestBody_routine.additionalData);
+  }
+}
+function serializePutRoutinesRequestExercise(writer, putRoutinesRequestExercise = {}) {
+  if (putRoutinesRequestExercise) {
+    writer.writeStringValue("exercise_template_id", putRoutinesRequestExercise.exerciseTemplateId);
+    writer.writeStringValue("notes", putRoutinesRequestExercise.notes);
+    writer.writeNumberValue("rest_seconds", putRoutinesRequestExercise.restSeconds);
+    writer.writeCollectionOfObjectValues("sets", putRoutinesRequestExercise.sets, serializePutRoutinesRequestSet);
+    writer.writeNumberValue("superset_id", putRoutinesRequestExercise.supersetId);
+    writer.writeAdditionalData(putRoutinesRequestExercise.additionalData);
+  }
+}
+function serializePutRoutinesRequestSet(writer, putRoutinesRequestSet = {}) {
+  if (putRoutinesRequestSet) {
+    writer.writeNumberValue("custom_metric", putRoutinesRequestSet.customMetric);
+    writer.writeNumberValue("distance_meters", putRoutinesRequestSet.distanceMeters);
+    writer.writeNumberValue("duration_seconds", putRoutinesRequestSet.durationSeconds);
+    writer.writeNumberValue("reps", putRoutinesRequestSet.reps);
+    writer.writeEnumValue("type", putRoutinesRequestSet.type);
+    writer.writeNumberValue("weight_kg", putRoutinesRequestSet.weightKg);
+    writer.writeAdditionalData(putRoutinesRequestSet.additionalData);
+  }
+}
+
+// src/generated/client/v1/exercise_templates/item/index.ts
+var WithExerciseTemplateItemRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates/{exerciseTemplateId}";
+var WithExerciseTemplateItemRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: WithExerciseTemplateItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createExerciseTemplateFromDiscriminatorValue
+  }
+};
+
+// src/generated/client/v1/exercise_templates/index.ts
+function createExercise_templatesGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoExercise_templatesGetResponse;
+}
+function deserializeIntoExercise_templatesGetResponse(exercise_templatesGetResponse = {}) {
+  return {
+    "exercise_templates": (n) => {
+      exercise_templatesGetResponse.exerciseTemplates = n.getCollectionOfObjectValues(createExerciseTemplateFromDiscriminatorValue);
+    },
+    "page": (n) => {
+      exercise_templatesGetResponse.page = n.getNumberValue();
+    },
+    "page_count": (n) => {
+      exercise_templatesGetResponse.pageCount = n.getNumberValue();
+    }
+  };
+}
+var Exercise_templatesRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates{?page*,pageSize*}";
+var Exercise_templatesRequestBuilderNavigationMetadata = {
+  byExerciseTemplateId: {
+    requestsMetadata: WithExerciseTemplateItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["exerciseTemplateId"]
+  }
+};
+var Exercise_templatesRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: Exercise_templatesRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createExercise_templatesGetResponseFromDiscriminatorValue
+  }
+};
+
+// src/generated/client/v1/routine_folders/item/index.ts
+var WithFolderItemRequestBuilderUriTemplate = "{+baseurl}/v1/routine_folders/{folderId}";
+var WithFolderItemRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: WithFolderItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFolderFromDiscriminatorValue
+  }
+};
+
+// src/generated/client/v1/routine_folders/index.ts
+function createRoutine_foldersGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine_foldersGetResponse;
+}
+function createRoutineFolder400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutineFolder400Error;
+}
+function deserializeIntoRoutine_foldersGetResponse(routine_foldersGetResponse = {}) {
+  return {
+    "page": (n) => {
+      routine_foldersGetResponse.page = n.getNumberValue();
+    },
+    "page_count": (n) => {
+      routine_foldersGetResponse.pageCount = n.getNumberValue();
+    },
+    "routine_folders": (n) => {
+      routine_foldersGetResponse.routineFolders = n.getCollectionOfObjectValues(createRoutineFolderFromDiscriminatorValue);
+    }
+  };
+}
+function deserializeIntoRoutineFolder400Error(routineFolder400Error = {}) {
+  return {
+    "error": (n) => {
+      routineFolder400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+var Routine_foldersRequestBuilderUriTemplate = "{+baseurl}/v1/routine_folders{?page*,pageSize*}";
+var Routine_foldersRequestBuilderNavigationMetadata = {
+  byFolderId: {
+    requestsMetadata: WithFolderItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["folderId"]
+  }
+};
+var Routine_foldersRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutine_foldersGetResponseFromDiscriminatorValue
+  },
+  post: {
+    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createRoutineFolder400ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFolderFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePostRoutineFolderRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
+  }
+};
+
+// src/generated/client/v1/routines/item/index.ts
+function createRoutine400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine400Error;
+}
+function createRoutine404ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine404Error;
+}
+function deserializeIntoRoutine400Error(routine400Error = {}) {
+  return {
+    "error": (n) => {
+      routine400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine404Error(routine404Error = {}) {
+  return {
+    "error": (n) => {
+      routine404Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+var WithRoutineItemRequestBuilderUriTemplate = "{+baseurl}/v1/routines/{routineId}";
+var WithRoutineItemRequestBuilderRequestsMetadata = {
+  put: {
+    uriTemplate: WithRoutineItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createRoutine400ErrorFromDiscriminatorValue,
+      404: createRoutine404ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePutRoutinesRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
+  }
+};
+
+// src/generated/client/v1/routines/index.ts
+function createRoutine400ErrorFromDiscriminatorValue2(parseNode) {
+  return deserializeIntoRoutine400Error2;
+}
+function createRoutine403ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine403Error;
+}
+function createRoutinesGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutinesGetResponse;
+}
+function deserializeIntoRoutine400Error2(routine400Error = {}) {
+  return {
+    "error": (n) => {
+      routine400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine403Error(routine403Error = {}) {
+  return {
+    "error": (n) => {
+      routine403Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutinesGetResponse(routinesGetResponse = {}) {
+  return {
+    "page": (n) => {
+      routinesGetResponse.page = n.getNumberValue();
+    },
+    "page_count": (n) => {
+      routinesGetResponse.pageCount = n.getNumberValue();
+    },
+    "routines": (n) => {
+      routinesGetResponse.routines = n.getCollectionOfObjectValues(createRoutineFromDiscriminatorValue);
+    }
+  };
+}
+var RoutinesRequestBuilderUriTemplate = "{+baseurl}/v1/routines{?page*,pageSize*}";
+var RoutinesRequestBuilderNavigationMetadata = {
+  byRoutineId: {
+    requestsMetadata: WithRoutineItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["routineId"]
+  }
+};
+var RoutinesRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: RoutinesRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutinesGetResponseFromDiscriminatorValue
+  },
+  post: {
+    uriTemplate: RoutinesRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createRoutine400ErrorFromDiscriminatorValue2,
+      403: createRoutine403ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePostRoutinesRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
+  }
+};
+
+// src/generated/client/v1/workouts/count/index.ts
+function createCountGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoCountGetResponse;
+}
+function deserializeIntoCountGetResponse(countGetResponse = {}) {
+  return {
+    "workout_count": (n) => {
+      countGetResponse.workoutCount = n.getNumberValue();
+    }
+  };
+}
+var CountRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/count";
+var CountRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: CountRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createCountGetResponseFromDiscriminatorValue
+  }
+};
+
+// src/generated/client/v1/workouts/events/index.ts
+var EventsRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/events{?page*,pageSize*,since*}";
+var EventsRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: EventsRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createPaginatedWorkoutEventsFromDiscriminatorValue
+  }
+};
+
+// src/generated/client/v1/workouts/item/index.ts
+function createWorkout400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkout400Error;
+}
+function deserializeIntoWorkout400Error(workout400Error = {}) {
+  return {
+    "error": (n) => {
+      workout400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+var WithWorkoutItemRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/{workoutId}";
+var WithWorkoutItemRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: WithWorkoutItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createWorkoutFromDiscriminatorValue
+  },
+  put: {
+    uriTemplate: WithWorkoutItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createWorkout400ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createWorkoutFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePostWorkoutsRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
+  }
+};
+
+// src/generated/client/v1/workouts/index.ts
+function createWorkout400ErrorFromDiscriminatorValue2(parseNode) {
+  return deserializeIntoWorkout400Error2;
+}
+function createWorkoutsGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkoutsGetResponse;
+}
+function deserializeIntoWorkout400Error2(workout400Error = {}) {
+  return {
+    "error": (n) => {
+      workout400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoWorkoutsGetResponse(workoutsGetResponse = {}) {
+  return {
+    "page": (n) => {
+      workoutsGetResponse.page = n.getNumberValue();
+    },
+    "page_count": (n) => {
+      workoutsGetResponse.pageCount = n.getNumberValue();
+    },
+    "workouts": (n) => {
+      workoutsGetResponse.workouts = n.getCollectionOfObjectValues(createWorkoutFromDiscriminatorValue);
+    }
+  };
+}
+var WorkoutsRequestBuilderUriTemplate = "{+baseurl}/v1/workouts{?page*,pageSize*}";
+var WorkoutsRequestBuilderNavigationMetadata = {
+  byWorkoutId: {
+    requestsMetadata: WithWorkoutItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["workoutId"]
+  },
+  count: {
+    requestsMetadata: CountRequestBuilderRequestsMetadata
+  },
+  events: {
+    requestsMetadata: EventsRequestBuilderRequestsMetadata
+  }
+};
+var WorkoutsRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: WorkoutsRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createWorkoutsGetResponseFromDiscriminatorValue
+  },
+  post: {
+    uriTemplate: WorkoutsRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createWorkout400ErrorFromDiscriminatorValue2
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createWorkoutFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePostWorkoutsRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
+  }
+};
+
+// src/generated/client/v1/index.ts
+var V1RequestBuilderNavigationMetadata = {
+  exercise_templates: {
+    requestsMetadata: Exercise_templatesRequestBuilderRequestsMetadata,
+    navigationMetadata: Exercise_templatesRequestBuilderNavigationMetadata
+  },
+  routines: {
+    requestsMetadata: RoutinesRequestBuilderRequestsMetadata,
+    navigationMetadata: RoutinesRequestBuilderNavigationMetadata
+  },
+  routine_folders: {
+    requestsMetadata: Routine_foldersRequestBuilderRequestsMetadata,
+    navigationMetadata: Routine_foldersRequestBuilderNavigationMetadata
+  },
+  workouts: {
+    requestsMetadata: WorkoutsRequestBuilderRequestsMetadata,
+    navigationMetadata: WorkoutsRequestBuilderNavigationMetadata
+  }
+};
+
+// src/generated/client/hevyClient.ts
+import { apiClientProxifier, registerDefaultDeserializer, registerDefaultSerializer } from "@microsoft/kiota-abstractions";
+
+// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formParseNode.js
+import { createBackedModelProxyHandler, DateOnly, Duration, parseGuidString, TimeOnly, isBackingStoreEnabled, getEnumValueFromStringValue } from "@microsoft/kiota-abstractions";
+var FormParseNode = class _FormParseNode {
+  /**
+   *  Creates a new instance of FormParseNode
+   * @param _rawString the raw string to parse
+   * @param backingStoreFactory the factory to create backing stores
+   */
+  constructor(_rawString, backingStoreFactory) {
+    this._rawString = _rawString;
+    this.backingStoreFactory = backingStoreFactory;
+    this._fields = {};
+    this.normalizeKey = (key) => decodeURIComponent(key).trim();
+    this.getStringValue = () => decodeURIComponent(this._rawString);
+    this.getChildNode = (identifier) => {
+      if (this._fields[identifier]) {
+        return new _FormParseNode(this._fields[identifier], this.backingStoreFactory);
+      }
+      return void 0;
+    };
+    this.getBooleanValue = () => {
+      var _a;
+      const value = (_a = this.getStringValue()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+      if (value === "true" || value === "1") {
+        return true;
+      } else if (value === "false" || value === "0") {
+        return false;
+      }
+      return void 0;
+    };
+    this.getNumberValue = () => parseFloat(this.getStringValue());
+    this.getGuidValue = () => parseGuidString(this.getStringValue());
+    this.getDateValue = () => new Date(Date.parse(this.getStringValue()));
+    this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
+    this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
+    this.getDurationValue = () => Duration.parse(this.getStringValue());
+    this.getCollectionOfPrimitiveValues = () => {
+      return this._rawString.split(",").map((x) => {
+        const currentParseNode = new _FormParseNode(x, this.backingStoreFactory);
+        const typeOfX = typeof x;
+        if (typeOfX === "boolean") {
+          return currentParseNode.getBooleanValue();
+        } else if (typeOfX === "string") {
+          return currentParseNode.getStringValue();
+        } else if (typeOfX === "number") {
+          return currentParseNode.getNumberValue();
+        } else if (x instanceof Date) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof DateOnly) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof TimeOnly) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof Duration) {
+          return currentParseNode.getDateValue();
+        } else {
+          throw new Error(`encountered an unknown type during deserialization ${typeof x}`);
+        }
+      });
+    };
+    this.getCollectionOfObjectValues = (parsableFactory) => {
+      throw new Error(`serialization of collections is not supported with URI encoding`);
+    };
+    this.getObjectValue = (parsableFactory) => {
+      const temp = {};
+      const enableBackingStore = isBackingStoreEnabled(parsableFactory(this)(temp));
+      const value = enableBackingStore && this.backingStoreFactory ? new Proxy(temp, createBackedModelProxyHandler(this.backingStoreFactory)) : temp;
+      if (this.onBeforeAssignFieldValues) {
+        this.onBeforeAssignFieldValues(value);
+      }
+      this.assignFieldValues(value, parsableFactory);
+      if (this.onAfterAssignFieldValues) {
+        this.onAfterAssignFieldValues(value);
+      }
+      return value;
+    };
+    this.getCollectionOfEnumValues = (type) => {
+      const rawValues = this.getStringValue();
+      if (!rawValues) {
+        return [];
+      }
+      return rawValues.split(",").map((x) => getEnumValueFromStringValue(x, type));
+    };
+    this.getEnumValue = (type) => {
+      const rawValue = this.getStringValue();
+      if (!rawValue) {
+        return void 0;
+      }
+      return getEnumValueFromStringValue(rawValue, type);
+    };
+    this.assignFieldValues = (model, parsableFactory) => {
+      const fields = parsableFactory(this)(model);
+      Object.entries(this._fields).filter((x) => !/^null$/i.test(x[1])).forEach(([k, v]) => {
+        const deserializer = fields[k];
+        if (deserializer) {
+          deserializer(new _FormParseNode(v, this.backingStoreFactory));
+        } else {
+          model[k] = v;
+        }
+      });
+    };
+    if (!_rawString) {
+      throw new Error("rawString cannot be undefined");
+    }
+    _rawString.split("&").map((x) => x.split("=")).filter((x) => x.length === 2).forEach((x) => {
+      const key = this.normalizeKey(x[0]);
+      if (this._fields[key]) {
+        this._fields[key] += "," + x[1];
+      } else {
+        this._fields[key] = x[1];
+      }
+    });
+  }
+  getByteArrayValue() {
+    throw new Error("serialization of byt arrays is not supported with URI encoding");
+  }
+};
+
+// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formSerializationWriter.js
+import { DateOnly as DateOnly2, Duration as Duration2, TimeOnly as TimeOnly2 } from "@microsoft/kiota-abstractions";
+var FormSerializationWriter = class _FormSerializationWriter {
+  constructor() {
+    this.writer = [];
+    this.depth = -1;
+    this.writeStringValue = (key, value) => {
+      if (value === null) {
+        value = "null";
+      }
+      if (key && value) {
+        this.writePropertyName(key);
+        this.writer.push(`=${encodeURIComponent(value)}`);
+        this.writer.push(_FormSerializationWriter.propertySeparator);
+      }
+    };
+    this.writePropertyName = (key) => {
+      this.writer.push(encodeURIComponent(key));
+    };
+    this.shouldWriteValueOrNull = (key, value) => {
+      if (value === null) {
+        this.writeNullValue(key);
+        return false;
+      }
+      return true;
+    };
+    this.writeBooleanValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value !== void 0 && this.writeStringValue(key, `${value}`);
+      }
+    };
+    this.writeNumberValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, `${value}`);
+      }
+    };
+    this.writeGuidValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeDateValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toISOString());
+      }
+    };
+    this.writeDateOnlyValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeTimeOnlyValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeDurationValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeNullValue = (key) => {
+      key && this.writeStringValue(key, null);
+    };
+    this.writeCollectionOfPrimitiveValues = (_key, _values) => {
+      if (_key && _values) {
+        _values.forEach((val) => {
+          this.writeAnyValue(_key, val);
+        });
+      }
+    };
+    this.writeCollectionOfObjectValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with URI encoding`);
+    };
+    this.writeObjectValue = (key, value, serializerMethod) => {
+      if (++this.depth > 0) {
+        throw new Error(`serialization of nested objects is not supported with URI encoding`);
+      }
+      if (!this.shouldWriteValueOrNull(key, value)) {
+        return;
+      }
+      if (value) {
+        if (key) {
+          this.writePropertyName(key);
+        }
+        this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
+        this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+        serializerMethod(this, value);
+        this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+        if (this.writer.length > 0 && this.writer[this.writer.length - 1] === _FormSerializationWriter.propertySeparator) {
+          this.writer.pop();
+        }
+        key && this.writer.push(_FormSerializationWriter.propertySeparator);
+      }
+    };
+    this.writeEnumValue = (key, ...values) => {
+      if (values.length > 0) {
+        const rawValues = values.filter((x) => x !== void 0).map((x) => `${x}`);
+        if (rawValues.length > 0) {
+          this.writeStringValue(key, rawValues.reduce((x, y) => `${x}, ${y}`));
+        }
+      }
+    };
+    this.writeCollectionOfEnumValues = (key, values) => {
+      if (key && values && values.length > 0) {
+        const rawValues = values.filter((x) => x !== void 0).map((x) => `${x}`);
+        if (rawValues.length > 0) {
+          this.writeCollectionOfPrimitiveValues(key, rawValues);
+        }
+      }
+    };
+    this.getSerializedContent = () => {
+      return this.convertStringToArrayBuffer(this.writer.join(``));
+    };
+    this.convertStringToArrayBuffer = (str) => {
+      const encoder = new TextEncoder();
+      const encodedString = encoder.encode(str);
+      return encodedString.buffer;
+    };
+    this.writeAdditionalData = (additionalData) => {
+      if (additionalData === void 0)
+        return;
+      for (const key in additionalData) {
+        this.writeAnyValue(key, additionalData[key]);
+      }
+    };
+    this.writeAnyValue = (key, value) => {
+      if (value === null) {
+        return this.writeNullValue(key);
+      }
+      if (value !== void 0) {
+        const valueType = typeof value;
+        if (valueType === "boolean") {
+          this.writeBooleanValue(key, value);
+        } else if (valueType === "string") {
+          this.writeStringValue(key, value);
+        } else if (value instanceof Date) {
+          this.writeDateValue(key, value);
+        } else if (value instanceof DateOnly2) {
+          this.writeDateOnlyValue(key, value);
+        } else if (value instanceof TimeOnly2) {
+          this.writeTimeOnlyValue(key, value);
+        } else if (value instanceof Duration2) {
+          this.writeDurationValue(key, value);
+        } else if (valueType === "number") {
+          this.writeNumberValue(key, value);
+        } else {
+          throw new Error(`encountered unknown ${value} value type during serialization ${valueType} for key ${key}`);
+        }
+      }
+    };
+  }
+  writeByteArrayValue(key, value) {
+    throw new Error("serialization of byt arrays is not supported with URI encoding");
+  }
+};
+FormSerializationWriter.propertySeparator = `&`;
+
+// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formParseNodeFactory.js
+var FormParseNodeFactory = class {
+  /**
+   * Creates an instance of JsonParseNode.
+   * @param backingStoreFactory - The factory to create backing stores.
+   */
+  constructor(backingStoreFactory) {
+    this.backingStoreFactory = backingStoreFactory;
+  }
+  getValidContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+  getRootParseNode(contentType, content) {
+    if (!content) {
+      throw new Error("content cannot be undefined of empty");
+    } else if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new FormParseNode(this.convertArrayBufferToString(content), this.backingStoreFactory);
+  }
+  convertArrayBufferToString(content) {
+    const decoder = new TextDecoder();
+    return decoder.decode(content);
+  }
+};
+
+// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formSerializationWriterFactory.js
+var FormSerializationWriterFactory = class {
+  getValidContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+  getSerializationWriter(contentType) {
+    if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new FormSerializationWriter();
+  }
+};
+
+// src/generated/client/hevyClient.ts
+import { JsonParseNodeFactory, JsonSerializationWriterFactory } from "@microsoft/kiota-serialization-json";
+
+// node_modules/@microsoft/kiota-serialization-multipart/dist/es/src/multipartSerializationWriter.js
+import { MultipartBody } from "@microsoft/kiota-abstractions";
+var MultipartSerializationWriter = class {
+  constructor() {
+    this.writer = new ArrayBuffer(0);
+    this.writeStringValue = (key, value) => {
+      if (key) {
+        this.writeRawStringValue(key);
+      }
+      if (value) {
+        if (key) {
+          this.writeRawStringValue(": ");
+        }
+        this.writeRawStringValue(value);
+      }
+    };
+    this.writeRawStringValue = (value) => {
+      if (value) {
+        this.writeByteArrayValue(void 0, new TextEncoder().encode(value).buffer);
+      }
+    };
+    this.writeBooleanValue = (key, value) => {
+      throw new Error(`serialization of boolean values is not supported with multipart`);
+    };
+    this.writeNumberValue = (key, value) => {
+      throw new Error(`serialization of number values is not supported with multipart`);
+    };
+    this.writeGuidValue = (key, value) => {
+      throw new Error(`serialization of guid values is not supported with multipart`);
+    };
+    this.writeDateValue = (key, value) => {
+      throw new Error(`serialization of date values is not supported with multipart`);
+    };
+    this.writeDateOnlyValue = (key, value) => {
+      throw new Error(`serialization of date only values is not supported with multipart`);
+    };
+    this.writeTimeOnlyValue = (key, value) => {
+      throw new Error(`serialization of time only values is not supported with multipart`);
+    };
+    this.writeDurationValue = (key, value) => {
+      throw new Error(`serialization of duration values is not supported with multipart`);
+    };
+    this.writeNullValue = (key) => {
+      throw new Error(`serialization of null values is not supported with multipart`);
+    };
+    this.writeCollectionOfPrimitiveValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with multipart`);
+    };
+    this.writeCollectionOfObjectValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with multipart`);
+    };
+    this.writeObjectValue = (key, value, serializerMethod) => {
+      if (!value) {
+        throw new Error(`value cannot be undefined`);
+      }
+      if (!(value instanceof MultipartBody)) {
+        throw new Error(`expected MultipartBody instance`);
+      }
+      if (!serializerMethod) {
+        throw new Error(`serializer method cannot be undefined`);
+      }
+      this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
+      this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+      serializerMethod(this, value);
+      this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+    };
+    this.writeEnumValue = (key, ...values) => {
+      throw new Error(`serialization of enum values is not supported with multipart`);
+    };
+    this.writeCollectionOfEnumValues = (key, values) => {
+      throw new Error(`serialization of collection of enum values is not supported with multipart`);
+    };
+    this.getSerializedContent = () => {
+      return this.writer;
+    };
+    this.writeAdditionalData = (additionalData) => {
+      throw new Error(`serialization of additional data is not supported with multipart`);
+    };
+  }
+  writeByteArrayValue(key, value) {
+    if (!value) {
+      throw new Error("value cannot be undefined");
+    }
+    const previousValue = this.writer;
+    this.writer = new ArrayBuffer(previousValue.byteLength + value.byteLength);
+    const pipe = new Uint8Array(this.writer);
+    pipe.set(new Uint8Array(previousValue), 0);
+    pipe.set(new Uint8Array(value), previousValue.byteLength);
+  }
+};
+
+// node_modules/@microsoft/kiota-serialization-multipart/dist/es/src/multipartSerializationWriterFactory.js
+var MultipartSerializationWriterFactory = class {
+  getValidContentType() {
+    return "multipart/form-data";
+  }
+  getSerializationWriter(contentType) {
+    if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new MultipartSerializationWriter();
+  }
+};
+
+// src/generated/client/hevyClient.ts
+import { TextParseNodeFactory, TextSerializationWriterFactory } from "@microsoft/kiota-serialization-text";
+function createHevyClient(requestAdapter) {
+  registerDefaultSerializer(JsonSerializationWriterFactory);
+  registerDefaultSerializer(TextSerializationWriterFactory);
+  registerDefaultSerializer(FormSerializationWriterFactory);
+  registerDefaultSerializer(MultipartSerializationWriterFactory);
+  registerDefaultDeserializer(JsonParseNodeFactory);
+  registerDefaultDeserializer(TextParseNodeFactory);
+  registerDefaultDeserializer(FormParseNodeFactory);
+  const pathParameters = {
+    "baseurl": requestAdapter.baseUrl
+  };
+  return apiClientProxifier(requestAdapter, pathParameters, HevyClientNavigationMetadata, void 0);
+}
+var HevyClientNavigationMetadata = {
+  v1: {
+    navigationMetadata: V1RequestBuilderNavigationMetadata
+  }
+};
+
+// src/utils/hevyClient.ts
+var ApiKeyAuthProvider = class {
+  apiKey;
+  constructor(apiKey2) {
+    this.apiKey = apiKey2;
+  }
+  async authenticateRequest(request) {
+    request.headers.add("x-api-key", this.apiKey);
+  }
+};
+function createClient(apiKey2, baseUrl) {
+  const authProvider = new ApiKeyAuthProvider(apiKey2);
+  const adapter = new FetchRequestAdapter(authProvider);
+  adapter.baseUrl = baseUrl;
+  return createHevyClient(adapter);
+}
+
+// src/index.ts
+var HEVY_API_BASEURL = "https://api.hevyapp.com/";
+var server = new McpServer({
+  name: "hevy",
+  version: "1.0.0"
+});
+if (!process.env.API_KEY) {
+  console.error("API_KEY environment variable is not set");
+  process.exit(1);
+}
+var apiKey = process.env.API_KEY || "";
+var hevyClient = createClient(apiKey, HEVY_API_BASEURL);
+registerWorkoutTools(server, hevyClient);
+registerRoutineTools(server, hevyClient);
+registerTemplateTools(server, hevyClient);
+registerFolderTools(server, hevyClient);
+async function runServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+runServer().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map