hevy-mcp 1.4.0 → 1.7.0

package/dist/index.js

@@ -7,29 +7,84 @@ import "@dotenvx/dotenvx/config";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// package.json
+var name = "hevy-mcp";
+var version = "1.7.0";
+
 // src/tools/folders.ts
 import { z } from "zod";
 
+// src/utils/error-handler.ts
+function createErrorResponse(error, context) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorCode = error instanceof Error && "code" in error ? error.code : void 0;
+  const errorType = determineErrorType(error, errorMessage);
+  if (errorCode) {
+    console.debug(`Error code: ${errorCode}`);
+  }
+  const contextPrefix = context ? `[${context}] ` : "";
+  const formattedMessage = `${contextPrefix}Error: ${errorMessage}`;
+  console.error(`${formattedMessage} (Type: ${errorType})`, error);
+  return {
+    content: [
+      {
+        type: "text",
+        text: formattedMessage
+      }
+    ],
+    isError: true
+  };
+}
+function determineErrorType(error, message) {
+  const messageLower = message.toLowerCase();
+  const nameLower = error instanceof Error ? error.name.toLowerCase() : "";
+  if (nameLower.includes("network") || messageLower.includes("network") || nameLower.includes("fetch") || messageLower.includes("fetch") || nameLower.includes("timeout") || messageLower.includes("timeout")) {
+    return "NETWORK_ERROR" /* NETWORK_ERROR */;
+  }
+  if (nameLower.includes("validation") || messageLower.includes("validation") || messageLower.includes("invalid") || messageLower.includes("required")) {
+    return "VALIDATION_ERROR" /* VALIDATION_ERROR */;
+  }
+  if (messageLower.includes("not found") || messageLower.includes("404") || messageLower.includes("does not exist")) {
+    return "NOT_FOUND" /* NOT_FOUND */;
+  }
+  if (nameLower.includes("api") || messageLower.includes("api") || messageLower.includes("server error") || messageLower.includes("500")) {
+    return "API_ERROR" /* API_ERROR */;
+  }
+  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+}
+function withErrorHandling(fn, context) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      return createErrorResponse(error, context);
+    }
+  };
+}
+
 // src/utils/formatters.ts
 function formatWorkout(workout) {
   return {
     id: workout.id,
-    date: workout.createdAt,
+    date: workout.created_at,
     name: workout.title,
     description: workout.description,
-    duration: calculateDuration(workout.startTime || "", workout.endTime || ""),
+    duration: calculateDuration(
+      workout.start_time || "",
+      workout.end_time || ""
+    ),
     exercises: workout.exercises?.map((exercise) => {
       return {
         name: exercise.title,
         notes: exercise.notes,
         sets: exercise.sets?.map((set) => ({
           type: set.type,
-          weight: set.weightKg,
+          weight: set.weight_kg,
           reps: set.reps,
-          distance: set.distanceMeters,
-          duration: set.durationSeconds,
+          distance: set.distance_meters,
+          duration: set.duration_seconds,
           rpe: set.rpe,
-          customMetric: set.customMetric
+          customMetric: set.custom_metric
         }))
       };
     })
@@ -39,24 +94,24 @@ function formatRoutine(routine) {
   return {
     id: routine.id,
     title: routine.title,
-    folderId: routine.folderId,
-    createdAt: routine.createdAt,
-    updatedAt: routine.updatedAt,
+    folderId: routine.folder_id,
+    createdAt: routine.created_at,
+    updatedAt: routine.updated_at,
     exercises: routine.exercises?.map((exercise) => {
       return {
         name: exercise.title,
         index: exercise.index,
-        exerciseTemplateId: exercise.exerciseTemplateId,
+        exerciseTemplateId: exercise.exercise_template_id,
         notes: exercise.notes,
-        supersetId: exercise.supersetsId,
+        supersetId: exercise.supersets_id,
         sets: exercise.sets?.map((set) => ({
           index: set.index,
           type: set.type,
-          weight: set.weightKg,
+          weight: set.weight_kg,
           reps: set.reps,
-          distance: set.distanceMeters,
-          duration: set.durationSeconds,
-          customMetric: set.customMetric
+          distance: set.distance_meters,
+          duration: set.duration_seconds,
+          customMetric: set.custom_metric
         }))
       };
     })
@@ -66,8 +121,8 @@ function formatRoutineFolder(folder) {
   return {
     id: folder.id,
     title: folder.title,
-    createdAt: folder.createdAt,
-    updatedAt: folder.updatedAt
+    createdAt: folder.created_at,
+    updatedAt: folder.updated_at
   };
 }
 function calculateDuration(startTime, endTime) {
@@ -96,9 +151,32 @@ function formatExerciseTemplate(template) {
     id: template.id,
     title: template.title,
     type: template.type,
-    primaryMuscleGroup: template.primaryMuscleGroup,
-    secondaryMuscleGroups: template.secondaryMuscleGroups,
-    isCustom: template.isCustom
+    primaryMuscleGroup: template.primary_muscle_group,
+    secondaryMuscleGroups: template.secondary_muscle_groups,
+    isCustom: template.is_custom
+  };
+}
+
+// src/utils/response-formatter.ts
+function createJsonResponse(data, options = { pretty: true, indent: 2 }) {
+  const jsonString = options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data);
+  return {
+    content: [
+      {
+        type: "text",
+        text: jsonString
+      }
+    ]
+  };
+}
+function createEmptyResponse(message = "No data found") {
+  return {
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
   };
 }
 
@@ -106,130 +184,70 @@ function formatExerciseTemplate(template) {
 function registerFolderTools(server2, hevyClient2) {
   server2.tool(
     "get-routine-folders",
-    "Get a paginated list of routine folders available on the account. Returns folder details including ID, title, index (order position), and creation/update timestamps. Useful for organizing routines into categories.",
+    "Get a paginated list of your routine folders, including both default and custom folders. Useful for organizing and browsing your workout routines.",
     {
       page: z.coerce.number().int().gte(1).default(1),
       pageSize: z.coerce.number().int().gte(1).lte(10).default(5)
     },
-    async ({ page, pageSize }) => {
-      try {
-        const data = await hevyClient2.v1.routine_folders.get({
-          queryParameters: {
-            page,
-            pageSize
-          }
+    withErrorHandling(
+      async ({ page, pageSize }) => {
+        const data = await hevyClient2.getRoutineFolders({
+          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)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+        const folders = data?.routine_folders?.map(
+          (folder) => formatRoutineFolder(folder)
+        ) || [];
+        if (folders.length === 0) {
+          return createEmptyResponse(
+            "No routine folders found for the specified parameters"
+          );
+        }
+        return createJsonResponse(folders);
+      },
+      "get-routine-folders"
+    )
   );
   server2.tool(
     "get-routine-folder",
-    "Get complete details of a specific routine folder by ID. Returns all folder information including title, index (order position), and creation/update timestamps.",
+    "Get complete details of a specific routine folder by its ID, including name, creation date, and associated routines.",
     {
-      folderId: z.coerce.number().int()
+      folderId: z.string().min(1)
     },
-    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)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async ({ folderId }) => {
+      const data = await hevyClient2.getRoutineFolder(folderId);
+      if (!data) {
+        return createEmptyResponse(
+          `Routine folder with ID ${folderId} not found`
+        );
       }
-    }
+      const folder = formatRoutineFolder(data);
+      return createJsonResponse(folder);
+    }, "get-routine-folder")
   );
   server2.tool(
     "create-routine-folder",
-    "Create a new routine folder in your Hevy account. The folder will be created at index 0, and all other folders will have their indexes incremented. Returns the complete folder details upon successful creation including the newly assigned folder ID.",
+    "Create a new routine folder in your Hevy account. Requires a name for the folder. Returns the full folder details including the new folder ID.",
     {
-      title: z.string().min(1)
+      name: 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"
-              }
-            ]
-          };
+    withErrorHandling(async ({ name: name2 }) => {
+      const data = await hevyClient2.createRoutineFolder({
+        routine_folder: {
+          title: name2
         }
-        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)}`
-            }
-          ],
-          isError: true
-        };
+      });
+      if (!data) {
+        return createEmptyResponse(
+          "Failed to create routine folder: Server returned no data"
+        );
       }
-    }
+      const folder = formatRoutineFolder(data);
+      return createJsonResponse(folder, {
+        pretty: true,
+        indent: 2
+      });
+    }, "create-routine-folder")
   );
 }
 
@@ -238,92 +256,44 @@ import { z as z2 } from "zod";
 function registerRoutineTools(server2, hevyClient2) {
   server2.tool(
     "get-routines",
-    "Get a paginated list of routines. Returns routine details including title, creation date, folder assignment, and exercise configurations. Results include both default and custom routines.",
+    "Get a paginated list of your workout routines, including custom and default routines. Useful for browsing or searching your available routines.",
     {
       page: z2.coerce.number().int().gte(1).default(1),
       pageSize: z2.coerce.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)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async (args) => {
+      const { page, pageSize } = args;
+      const data = await hevyClient2.getRoutines({
+        page,
+        pageSize
+      });
+      const routines = data?.routines?.map((routine) => formatRoutine(routine)) || [];
+      if (routines.length === 0) {
+        return createEmptyResponse(
+          "No routines found for the specified parameters"
+        );
       }
-    }
+      return createJsonResponse(routines);
+    }, "get-routines")
   );
   server2.tool(
     "get-routine",
-    "Get complete details of a specific routine by ID. Returns all routine information including title, notes, assigned folder, and detailed exercise data with set configurations.",
+    "Get a routine by its ID using the direct endpoint. Returns all details for the specified routine.",
     {
       routineId: z2.string().min(1)
     },
-    async ({ routineId }) => {
-      try {
-        const data = await hevyClient2.v1.routines.byRoutineId(routineId).put({
-          routine: {
-            title: ""
-            // We're providing a minimal body as required by the API
-          }
-        });
-        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)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async ({ routineId }) => {
+      const data = await hevyClient2.getRoutineById(String(routineId));
+      if (!data || !data.routine) {
+        return createEmptyResponse(`Routine with ID ${routineId} not found`);
       }
-    }
+      const routine = formatRoutine(data.routine);
+      return createJsonResponse(routine);
+    }, "get-routine")
   );
   server2.tool(
     "create-routine",
-    "Create a new workout routine in your Hevy account. Requires title and at least one exercise with sets. Optionally assign to a specific folder. Returns the complete routine details upon successful creation including the newly assigned routine ID.",
+    "Create a new workout routine in your Hevy account. Requires a title and at least one exercise with sets. Optionally assign to a folder. Returns the full routine details including the new routine ID.",
     {
       title: z2.string().min(1),
       folderId: z2.coerce.number().nullable().optional(),
@@ -347,66 +317,48 @@ function registerRoutineTools(server2, hevyClient2) {
         })
       )
     },
-    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"
-              }
-            ]
-          };
+    withErrorHandling(async (args) => {
+      const { title, folderId, notes, exercises } = args;
+      const data = await hevyClient2.createRoutine({
+        routine: {
+          title,
+          folder_id: folderId ?? null,
+          notes: notes ?? "",
+          exercises: exercises.map(
+            (exercise) => ({
+              exercise_template_id: exercise.exerciseTemplateId,
+              superset_id: exercise.supersetId ?? null,
+              rest_seconds: exercise.restSeconds ?? null,
+              notes: exercise.notes ?? null,
+              sets: exercise.sets.map(
+                (set) => ({
+                  type: set.type,
+                  weight_kg: set.weightKg ?? null,
+                  reps: set.reps ?? null,
+                  distance_meters: set.distanceMeters ?? null,
+                  duration_seconds: set.durationSeconds ?? null,
+                  custom_metric: set.customMetric ?? null
+                })
+              )
+            })
+          )
         }
-        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)}`
-            }
-          ],
-          isError: true
-        };
+      });
+      if (!data) {
+        return createEmptyResponse(
+          "Failed to create routine: Server returned no data"
+        );
       }
-    }
+      const routine = formatRoutine(data);
+      return createJsonResponse(routine, {
+        pretty: true,
+        indent: 2
+      });
+    }, "create-routine")
   );
   server2.tool(
     "update-routine",
-    "Update an existing workout routine by ID. You can modify the title, notes, and exercise data. Returns the updated routine with all changes applied. Note that you cannot change the folder assignment through this method.",
+    "Update an existing routine by ID. You can modify the title, notes, and exercise configurations. Returns the updated routine with all changes applied.",
     {
       routineId: z2.string().min(1),
       title: z2.string().min(1),
@@ -430,61 +382,43 @@ ${JSON.stringify(routine, null, 2)}`
         })
       )
     },
-    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}`
-              }
-            ]
-          };
+    withErrorHandling(async (args) => {
+      const { routineId, title, notes, exercises } = args;
+      const data = await hevyClient2.updateRoutine(routineId, {
+        routine: {
+          title,
+          notes: notes ?? "",
+          exercises: exercises.map(
+            (exercise) => ({
+              exercise_template_id: exercise.exerciseTemplateId,
+              superset_id: exercise.supersetId ?? null,
+              rest_seconds: exercise.restSeconds ?? null,
+              notes: exercise.notes ?? null,
+              sets: exercise.sets.map(
+                (set) => ({
+                  type: set.type,
+                  weight_kg: set.weightKg ?? null,
+                  reps: set.reps ?? null,
+                  distance_meters: set.distanceMeters ?? null,
+                  duration_seconds: set.durationSeconds ?? null,
+                  custom_metric: set.customMetric ?? null
+                })
+              )
+            })
+          )
         }
-        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)}`
-            }
-          ],
-          isError: true
-        };
+      });
+      if (!data) {
+        return createEmptyResponse(
+          `Failed to update routine with ID ${routineId}`
+        );
       }
-    }
+      const routine = formatRoutine(data);
+      return createJsonResponse(routine, {
+        pretty: true,
+        indent: 2
+      });
+    }, "update-routine")
   );
 }
 
@@ -493,167 +427,625 @@ import { z as z3 } from "zod";
 function registerTemplateTools(server2, hevyClient2) {
   server2.tool(
     "get-exercise-templates",
-    "Get a paginated list of exercise templates available on the account. Returns both default and custom exercise templates with details including title, type, primary muscle group, and secondary muscle groups. Supports up to 100 templates per page.",
+    "Get a paginated list of exercise templates (default and custom) with details like name, category, equipment, and muscle groups. Useful for browsing or searching available exercises.",
     {
       page: z3.coerce.number().int().gte(1).default(1),
-      pageSize: z3.coerce.number().int().gte(1).lte(100).default(20)
+      pageSize: z3.coerce.number().int().gte(1).lte(100).default(5)
     },
-    async ({ page, pageSize }) => {
-      try {
-        const data = await hevyClient2.v1.exercise_templates.get({
-          queryParameters: {
-            page,
-            pageSize
-          }
+    withErrorHandling(
+      async ({ page, pageSize }) => {
+        const data = await hevyClient2.getExerciseTemplates({
+          page,
+          pageSize
         });
-        const templates = data?.exerciseTemplates?.map(
+        const templates = data?.exercise_templates?.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)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+        if (templates.length === 0) {
+          return createEmptyResponse(
+            "No exercise templates found for the specified parameters"
+          );
+        }
+        return createJsonResponse(templates);
+      },
+      "get-exercise-templates"
+    )
   );
   server2.tool(
     "get-exercise-template",
-    "Get complete details of a specific exercise template by ID. Returns all template information including title, type, primary muscle group, secondary muscle groups, and whether it's a custom exercise.",
+    "Get complete details of a specific exercise template by its ID, including name, category, equipment, muscle groups, and notes.",
     {
       exerciseTemplateId: z3.string().min(1)
     },
-    async ({ exerciseTemplateId }) => {
-      try {
-        const data = await hevyClient2.v1.exercise_templates.byExerciseTemplateId(exerciseTemplateId).get();
+    withErrorHandling(
+      async ({ exerciseTemplateId }) => {
+        const data = await hevyClient2.getExerciseTemplate(exerciseTemplateId);
         if (!data) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Exercise template with ID ${exerciseTemplateId} not found`
-              }
-            ]
-          };
+          return createEmptyResponse(
+            `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)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+        return createJsonResponse(template);
+      },
+      "get-exercise-template"
+    )
   );
 }
 
-// src/tools/workouts.ts
+// src/tools/webhooks.ts
+import { z as z40 } from "zod";
+
+// src/generated/client/schemas/deletedWorkoutSchema.ts
 import { z as z4 } from "zod";
+var deletedWorkoutSchema = z4.object({
+  type: z4.string().describe("Indicates the type of the event (deleted)"),
+  id: z4.string().describe("The unique identifier of the deleted workout"),
+  deleted_at: z4.string().describe("A date string indicating when the workout was deleted").optional()
+});
 
-// src/utils/error-handler.ts
-function createErrorResponse(error, context) {
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  const errorCode = error instanceof Error && "code" in error ? error.code : void 0;
-  if (errorCode) {
-    console.debug(`Error code: ${errorCode}`);
-  }
-  const contextPrefix = context ? `[${context}] ` : "";
-  const formattedMessage = `${contextPrefix}Error: ${errorMessage}`;
-  console.error(formattedMessage, error);
-  return {
-    content: [
-      {
-        type: "text",
-        text: formattedMessage
-      }
-    ],
-    isError: true
-  };
-}
-function withErrorHandling(fn, context) {
-  return async (...args) => {
-    try {
-      return await fn(...args);
-    } catch (error) {
-      return createErrorResponse(error, context);
-    }
-  };
-}
+// src/generated/client/schemas/deleteV1WebhookSubscriptionSchema.ts
+import { z as z5 } from "zod";
+var deleteV1WebhookSubscriptionHeaderParamsSchema = z5.object({
+  "api-key": z5.string().uuid().describe("Your API key")
+});
+var deleteV1WebhookSubscription200Schema = z5.any();
+var deleteV1WebhookSubscriptionMutationResponseSchema = z5.lazy(() => deleteV1WebhookSubscription200Schema);
 
-// src/utils/response-formatter.ts
-function createJsonResponse(data, options = { pretty: true, indent: 2 }) {
-  const jsonString = options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data);
-  return {
-    content: [
-      {
-        type: "text",
-        text: jsonString
-      }
-    ]
-  };
-}
-function createEmptyResponse(message = "No data found") {
-  return {
-    content: [
-      {
-        type: "text",
-        text: message
-      }
-    ]
-  };
-}
+// src/generated/client/schemas/exerciseTemplateSchema.ts
+import { z as z6 } from "zod";
+var exerciseTemplateSchema = z6.object({
+  id: z6.string().describe("The exercise template ID.").optional(),
+  title: z6.string().describe("The exercise title.").optional(),
+  type: z6.string().describe("The exercise type.").optional(),
+  primary_muscle_group: z6.string().describe("The primary muscle group of the exercise.").optional(),
+  secondary_muscle_groups: z6.array(z6.string()).describe("The secondary muscle groups of the exercise.").optional(),
+  is_custom: z6.boolean().describe("A boolean indicating whether the exercise is a custom exercise.").optional()
+});
 
-// src/tools/workouts.ts
-function registerWorkoutTools(server2, hevyClient2) {
-  server2.tool(
-    "get-workouts",
-    "Get a paginated list of workouts. Returns workout details including title, description, start/end times, and exercises performed. Results are ordered from newest to oldest.",
-    {
-      page: z4.coerce.number().gte(1).default(1),
-      pageSize: z4.coerce.number().int().gte(1).lte(10).default(5)
-    },
-    withErrorHandling(async ({ page, pageSize }) => {
-      const data = await hevyClient2.v1.workouts.get({
-        queryParameters: {
-          page,
-          pageSize
-        }
-      });
-      const workouts = data?.workouts?.map((workout) => formatWorkout(workout)) || [];
-      if (workouts.length === 0) {
-        return createEmptyResponse(
-          "No workouts found for the specified parameters"
+// src/generated/client/schemas/getV1ExerciseTemplatesExercisetemplateidSchema.ts
+import { z as z7 } from "zod";
+var getV1ExerciseTemplatesExercisetemplateidPathParamsSchema = z7.object({
+  exerciseTemplateId: z7.any()
+});
+var getV1ExerciseTemplatesExercisetemplateidHeaderParamsSchema = z7.object({
+  "api-key": z7.string().uuid()
+});
+var getV1ExerciseTemplatesExercisetemplateid200Schema = z7.lazy(() => exerciseTemplateSchema);
+var getV1ExerciseTemplatesExercisetemplateid404Schema = z7.any();
+var getV1ExerciseTemplatesExercisetemplateidQueryResponseSchema = z7.lazy(() => getV1ExerciseTemplatesExercisetemplateid200Schema);
+
+// src/generated/client/schemas/getV1ExerciseTemplatesSchema.ts
+import { z as z8 } from "zod";
+var getV1ExerciseTemplatesQueryParamsSchema = z8.object({
+  page: z8.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  pageSize: z8.coerce.number().int().default(5).describe("Number of items on the requested page (Max 100)")
+});
+var getV1ExerciseTemplatesHeaderParamsSchema = z8.object({
+  "api-key": z8.string().uuid()
+});
+var getV1ExerciseTemplates200Schema = z8.object({
+  page: z8.number().int().default(1).describe("Current page number"),
+  page_count: z8.number().int().default(5).describe("Total number of pages"),
+  exercise_templates: z8.array(z8.lazy(() => exerciseTemplateSchema)).optional()
+});
+var getV1ExerciseTemplates400Schema = z8.any();
+var getV1ExerciseTemplatesQueryResponseSchema = z8.lazy(() => getV1ExerciseTemplates200Schema);
+
+// src/generated/client/schemas/routineFolderSchema.ts
+import { z as z9 } from "zod";
+var routineFolderSchema = z9.object({
+  id: z9.number().describe("The routine folder ID.").optional(),
+  index: z9.number().describe("The routine folder index. Describes the order of the folder in the list.").optional(),
+  title: z9.string().describe("The routine folder title.").optional(),
+  updated_at: z9.string().describe("ISO 8601 timestamp of when the folder was last updated.").optional(),
+  created_at: z9.string().describe("ISO 8601 timestamp of when the folder was created.").optional()
+});
+
+// src/generated/client/schemas/getV1RoutineFoldersFolderidSchema.ts
+import { z as z10 } from "zod";
+var getV1RoutineFoldersFolderidPathParamsSchema = z10.object({
+  folderId: z10.any()
+});
+var getV1RoutineFoldersFolderidHeaderParamsSchema = z10.object({
+  "api-key": z10.string().uuid()
+});
+var getV1RoutineFoldersFolderid200Schema = z10.lazy(() => routineFolderSchema);
+var getV1RoutineFoldersFolderid404Schema = z10.any();
+var getV1RoutineFoldersFolderidQueryResponseSchema = z10.lazy(() => getV1RoutineFoldersFolderid200Schema);
+
+// src/generated/client/schemas/getV1RoutineFoldersSchema.ts
+import { z as z11 } from "zod";
+var getV1RoutineFoldersQueryParamsSchema = z11.object({
+  page: z11.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  pageSize: z11.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+});
+var getV1RoutineFoldersHeaderParamsSchema = z11.object({
+  "api-key": z11.string().uuid()
+});
+var getV1RoutineFolders200Schema = z11.object({
+  page: z11.number().int().default(1).describe("Current page number"),
+  page_count: z11.number().int().default(5).describe("Total number of pages"),
+  routine_folders: z11.array(z11.lazy(() => routineFolderSchema)).optional()
+});
+var getV1RoutineFolders400Schema = z11.any();
+var getV1RoutineFoldersQueryResponseSchema = z11.lazy(() => getV1RoutineFolders200Schema);
+
+// src/generated/client/schemas/routineSchema.ts
+import { z as z12 } from "zod";
+var routineSchema = z12.object({
+  id: z12.string().describe("The routine ID.").optional(),
+  title: z12.string().describe("The routine title.").optional(),
+  folder_id: z12.number().describe("The routine folder ID.").nullable().nullish(),
+  updated_at: z12.string().describe("ISO 8601 timestamp of when the routine was last updated.").optional(),
+  created_at: z12.string().describe("ISO 8601 timestamp of when the routine was created.").optional(),
+  exercises: z12.array(
+    z12.object({
+      index: z12.number().describe("Index indicating the order of the exercise in the routine.").optional(),
+      title: z12.string().describe("Title of the exercise").optional(),
+      rest_seconds: z12.string().describe("The rest time in seconds between sets of the exercise").optional(),
+      notes: z12.string().describe("Routine notes on the exercise").optional(),
+      exercise_template_id: z12.string().describe("The id of the exercise template. This can be used to fetch the exercise template.").optional(),
+      supersets_id: z12.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullable().nullish(),
+      sets: z12.array(
+        z12.object({
+          index: z12.number().describe("Index indicating the order of the set in the routine.").optional(),
+          type: z12.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'").optional(),
+          weight_kg: z12.number().describe("Weight lifted in kilograms.").nullable().nullish(),
+          reps: z12.number().describe("Number of reps logged for the set").nullable().nullish(),
+          distance_meters: z12.number().describe("Number of meters logged for the set").nullable().nullish(),
+          duration_seconds: z12.number().describe("Number of seconds logged for the set").nullable().nullish(),
+          rpe: z12.number().describe("RPE (Relative perceived exertion) value logged for the set").nullable().nullish(),
+          custom_metric: z12.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullable().nullish()
+        })
+      ).optional()
+    })
+  ).optional()
+});
+
+// src/generated/client/schemas/getV1RoutinesRoutineidSchema.ts
+import { z as z13 } from "zod";
+var getV1RoutinesRoutineidPathParamsSchema = z13.object({
+  routineId: z13.any()
+});
+var getV1RoutinesRoutineidHeaderParamsSchema = z13.object({
+  "api-key": z13.string().uuid()
+});
+var getV1RoutinesRoutineid200Schema = z13.object({
+  routine: z13.lazy(() => routineSchema).optional()
+});
+var getV1RoutinesRoutineid400Schema = z13.object({
+  error: z13.string().describe("Error message").optional()
+});
+var getV1RoutinesRoutineidQueryResponseSchema = z13.lazy(() => getV1RoutinesRoutineid200Schema);
+
+// src/generated/client/schemas/getV1RoutinesSchema.ts
+import { z as z14 } from "zod";
+var getV1RoutinesQueryParamsSchema = z14.object({
+  page: z14.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  pageSize: z14.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+});
+var getV1RoutinesHeaderParamsSchema = z14.object({
+  "api-key": z14.string().uuid()
+});
+var getV1Routines200Schema = z14.object({
+  page: z14.number().int().describe("Current page number").optional(),
+  page_count: z14.number().int().describe("Total number of pages").optional(),
+  routines: z14.array(z14.lazy(() => routineSchema)).optional()
+});
+var getV1Routines400Schema = z14.any();
+var getV1RoutinesQueryResponseSchema = z14.lazy(() => getV1Routines200Schema);
+
+// src/generated/client/schemas/getV1WebhookSubscriptionSchema.ts
+import { z as z15 } from "zod";
+var getV1WebhookSubscriptionHeaderParamsSchema = z15.object({
+  "api-key": z15.string().uuid().describe("Your API key")
+});
+var getV1WebhookSubscription200Schema = z15.object({
+  url: z15.string().describe("The webhook URL").optional(),
+  auth_token: z15.string().describe("The auth token for the webhook").optional()
+});
+var getV1WebhookSubscription404Schema = z15.any();
+var getV1WebhookSubscriptionQueryResponseSchema = z15.lazy(() => getV1WebhookSubscription200Schema);
+
+// src/generated/client/schemas/getV1WorkoutsCountSchema.ts
+import { z as z16 } from "zod";
+var getV1WorkoutsCountHeaderParamsSchema = z16.object({
+  "api-key": z16.string().uuid()
+});
+var getV1WorkoutsCount200Schema = z16.object({
+  workout_count: z16.number().int().default(42).describe("The total number of workouts")
+});
+var getV1WorkoutsCountQueryResponseSchema = z16.lazy(() => getV1WorkoutsCount200Schema);
+
+// src/generated/client/schemas/workoutSchema.ts
+import { z as z17 } from "zod";
+var workoutSchema = z17.object({
+  id: z17.string().describe("The workout ID.").optional(),
+  title: z17.string().describe("The workout title.").optional(),
+  description: z17.string().describe("The workout description.").optional(),
+  start_time: z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have started.").optional(),
+  end_time: z17.number().describe("ISO 8601 timestamp of when the workout was recorded to have ended.").optional(),
+  updated_at: z17.string().describe("ISO 8601 timestamp of when the workout was last updated.").optional(),
+  created_at: z17.string().describe("ISO 8601 timestamp of when the workout was created.").optional(),
+  exercises: z17.array(
+    z17.object({
+      index: z17.number().describe("Index indicating the order of the exercise in the workout.").optional(),
+      title: z17.string().describe("Title of the exercise").optional(),
+      notes: z17.string().describe("Notes on the exercise").optional(),
+      exercise_template_id: z17.string().describe("The id of the exercise template. This can be used to fetch the exercise template.").optional(),
+      supersets_id: z17.number().describe("The id of the superset that the exercise belongs to. A value of null indicates the exercise is not part of a superset.").nullable().nullish(),
+      sets: z17.array(
+        z17.object({
+          index: z17.number().describe("Index indicating the order of the set in the workout.").optional(),
+          type: z17.string().describe("The type of set. This can be one of 'normal', 'warmup', 'dropset', 'failure'").optional(),
+          weight_kg: z17.number().describe("Weight lifted in kilograms.").nullable().nullish(),
+          reps: z17.number().describe("Number of reps logged for the set").nullable().nullish(),
+          distance_meters: z17.number().describe("Number of meters logged for the set").nullable().nullish(),
+          duration_seconds: z17.number().describe("Number of seconds logged for the set").nullable().nullish(),
+          rpe: z17.number().describe("RPE (Relative perceived exertion) value logged for the set").nullable().nullish(),
+          custom_metric: z17.number().describe("Custom metric logged for the set (Currently only used to log floors or steps for stair machine exercises)").nullable().nullish()
+        })
+      ).optional()
+    })
+  ).optional()
+});
+
+// src/generated/client/schemas/updatedWorkoutSchema.ts
+import { z as z18 } from "zod";
+var updatedWorkoutSchema = z18.object({
+  type: z18.string().describe("Indicates the type of the event (updated)"),
+  workout: z18.lazy(() => workoutSchema)
+});
+
+// src/generated/client/schemas/paginatedWorkoutEventsSchema.ts
+import { z as z19 } from "zod";
+var paginatedWorkoutEventsSchema = z19.object({
+  page: z19.number().int().describe("The current page number"),
+  page_count: z19.number().int().describe("The total number of pages available"),
+  events: z19.array(z19.union([z19.lazy(() => updatedWorkoutSchema), z19.lazy(() => deletedWorkoutSchema)])).describe("An array of workout events (either updated or deleted)")
+});
+
+// src/generated/client/schemas/getV1WorkoutsEventsSchema.ts
+import { z as z20 } from "zod";
+var getV1WorkoutsEventsQueryParamsSchema = z20.object({
+  page: z20.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  pageSize: z20.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)"),
+  since: z20.string().default("1970-01-01T00:00:00Z")
+});
+var getV1WorkoutsEventsHeaderParamsSchema = z20.object({
+  "api-key": z20.string().uuid()
+});
+var getV1WorkoutsEvents200Schema = z20.lazy(() => paginatedWorkoutEventsSchema);
+var getV1WorkoutsEvents500Schema = z20.any();
+var getV1WorkoutsEventsQueryResponseSchema = z20.lazy(() => getV1WorkoutsEvents200Schema);
+
+// src/generated/client/schemas/getV1WorkoutsSchema.ts
+import { z as z21 } from "zod";
+var getV1WorkoutsQueryParamsSchema = z21.object({
+  page: z21.coerce.number().int().default(1).describe("Page number (Must be 1 or greater)"),
+  pageSize: z21.coerce.number().int().default(5).describe("Number of items on the requested page (Max 10)")
+});
+var getV1WorkoutsHeaderParamsSchema = z21.object({
+  "api-key": z21.string().uuid()
+});
+var getV1Workouts200Schema = z21.object({
+  page: z21.number().int().describe("Current page number").optional(),
+  page_count: z21.number().int().describe("Total number of pages").optional(),
+  workouts: z21.array(z21.lazy(() => workoutSchema)).optional()
+});
+var getV1Workouts400Schema = z21.any();
+var getV1WorkoutsQueryResponseSchema = z21.lazy(() => getV1Workouts200Schema);
+
+// src/generated/client/schemas/getV1WorkoutsWorkoutidSchema.ts
+import { z as z22 } from "zod";
+var getV1WorkoutsWorkoutidPathParamsSchema = z22.object({
+  workoutId: z22.any()
+});
+var getV1WorkoutsWorkoutidHeaderParamsSchema = z22.object({
+  "api-key": z22.string().uuid()
+});
+var getV1WorkoutsWorkoutid200Schema = z22.lazy(() => workoutSchema);
+var getV1WorkoutsWorkoutid404Schema = z22.any();
+var getV1WorkoutsWorkoutidQueryResponseSchema = z22.lazy(() => getV1WorkoutsWorkoutid200Schema);
+
+// src/generated/client/schemas/postRoutineFolderRequestBodySchema.ts
+import { z as z23 } from "zod";
+var postRoutineFolderRequestBodySchema = z23.object({
+  routine_folder: z23.object({
+    title: z23.string().describe("The title of the routine folder.").optional()
+  }).optional()
+});
+
+// src/generated/client/schemas/postRoutinesRequestSetSchema.ts
+import { z as z24 } from "zod";
+var postRoutinesRequestSetSchema = z24.object({
+  type: z24.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
+  weight_kg: z24.number().describe("The weight in kilograms.").nullable().nullish(),
+  reps: z24.number().int().describe("The number of repetitions.").nullable().nullish(),
+  distance_meters: z24.number().int().describe("The distance in meters.").nullable().nullish(),
+  duration_seconds: z24.number().int().describe("The duration in seconds.").nullable().nullish(),
+  custom_metric: z24.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish()
+});
+
+// src/generated/client/schemas/postRoutinesRequestExerciseSchema.ts
+import { z as z25 } from "zod";
+var postRoutinesRequestExerciseSchema = z25.object({
+  exercise_template_id: z25.string().describe("The ID of the exercise template.").optional(),
+  superset_id: z25.number().int().describe("The ID of the superset.").nullable().nullish(),
+  rest_seconds: z25.number().int().describe("The rest time in seconds.").nullable().nullish(),
+  notes: z25.string().describe("Additional notes for the exercise.").nullable().nullish(),
+  sets: z25.array(z25.lazy(() => postRoutinesRequestSetSchema)).optional()
+});
+
+// src/generated/client/schemas/postRoutinesRequestBodySchema.ts
+import { z as z26 } from "zod";
+var postRoutinesRequestBodySchema = z26.object({
+  routine: z26.object({
+    title: z26.string().describe("The title of the routine.").optional(),
+    folder_id: z26.number().describe('The folder id the routine should be added to. Pass null to insert the routine into default "My Routines" folder').nullable().nullish(),
+    notes: z26.string().describe("Additional notes for the routine.").optional(),
+    exercises: z26.array(z26.lazy(() => postRoutinesRequestExerciseSchema)).optional()
+  }).optional()
+});
+
+// src/generated/client/schemas/postV1RoutineFoldersSchema.ts
+import { z as z27 } from "zod";
+var postV1RoutineFoldersHeaderParamsSchema = z27.object({
+  "api-key": z27.string().uuid()
+});
+var postV1RoutineFolders201Schema = z27.lazy(() => routineFolderSchema);
+var postV1RoutineFolders400Schema = z27.object({
+  error: z27.string().describe("Error message").optional()
+});
+var postV1RoutineFoldersMutationRequestSchema = z27.lazy(() => postRoutineFolderRequestBodySchema);
+var postV1RoutineFoldersMutationResponseSchema = z27.lazy(() => postV1RoutineFolders201Schema);
+
+// src/generated/client/schemas/postV1RoutinesSchema.ts
+import { z as z28 } from "zod";
+var postV1RoutinesHeaderParamsSchema = z28.object({
+  "api-key": z28.string().uuid()
+});
+var postV1Routines201Schema = z28.lazy(() => routineSchema);
+var postV1Routines400Schema = z28.object({
+  error: z28.string().describe("Error message").optional()
+});
+var postV1Routines403Schema = z28.object({
+  error: z28.string().describe("Error message").optional()
+});
+var postV1RoutinesMutationRequestSchema = z28.lazy(() => postRoutinesRequestBodySchema);
+var postV1RoutinesMutationResponseSchema = z28.lazy(() => postV1Routines201Schema);
+
+// src/generated/client/schemas/webhookRequestBodySchema.ts
+import { z as z29 } from "zod";
+var webhookRequestBodySchema = z29.object({
+  authToken: z29.string().describe("The auth token that will be send as Authorization header in the webhook.").optional(),
+  url: z29.string().describe("The webhook URL.").optional()
+});
+
+// src/generated/client/schemas/postV1WebhookSubscriptionSchema.ts
+import { z as z30 } from "zod";
+var postV1WebhookSubscriptionHeaderParamsSchema = z30.object({
+  "api-key": z30.string().uuid()
+});
+var postV1WebhookSubscription201Schema = z30.any();
+var postV1WebhookSubscription400Schema = z30.object({
+  error: z30.string().describe("Error message").optional()
+});
+var postV1WebhookSubscriptionMutationRequestSchema = z30.lazy(() => webhookRequestBodySchema);
+var postV1WebhookSubscriptionMutationResponseSchema = z30.lazy(() => postV1WebhookSubscription201Schema);
+
+// src/generated/client/schemas/postWorkoutsRequestSetSchema.ts
+import { z as z31 } from "zod";
+var postWorkoutsRequestSetSchema = z31.object({
+  type: z31.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
+  weight_kg: z31.number().describe("The weight in kilograms.").nullable().nullish(),
+  reps: z31.number().int().describe("The number of repetitions.").nullable().nullish(),
+  distance_meters: z31.number().int().describe("The distance in meters.").nullable().nullish(),
+  duration_seconds: z31.number().int().describe("The duration in seconds.").nullable().nullish(),
+  custom_metric: z31.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish(),
+  rpe: z31.union([z31.literal(6), z31.literal(7), z31.literal(7.5), z31.literal(8), z31.literal(8.5), z31.literal(9), z31.literal(9.5), z31.literal(10)]).describe("The Rating of Perceived Exertion (RPE).").nullable().nullish()
+});
+
+// src/generated/client/schemas/postWorkoutsRequestExerciseSchema.ts
+import { z as z32 } from "zod";
+var postWorkoutsRequestExerciseSchema = z32.object({
+  exercise_template_id: z32.string().describe("The ID of the exercise template.").optional(),
+  superset_id: z32.number().int().describe("The ID of the superset.").nullable().nullish(),
+  notes: z32.string().describe("Additional notes for the exercise.").nullable().nullish(),
+  sets: z32.array(z32.lazy(() => postWorkoutsRequestSetSchema)).optional()
+});
+
+// src/generated/client/schemas/postWorkoutsRequestBodySchema.ts
+import { z as z33 } from "zod";
+var postWorkoutsRequestBodySchema = z33.object({
+  workout: z33.object({
+    title: z33.string().describe("The title of the workout.").optional(),
+    description: z33.string().describe("A description for the workout workout.").nullable().nullish(),
+    start_time: z33.string().describe("The time the workout started.").optional(),
+    end_time: z33.string().describe("The time the workout ended.").optional(),
+    is_private: z33.boolean().describe("A boolean indicating if the workout is private.").optional(),
+    exercises: z33.array(z33.lazy(() => postWorkoutsRequestExerciseSchema)).optional()
+  }).optional()
+});
+
+// src/generated/client/schemas/postV1WorkoutsSchema.ts
+import { z as z34 } from "zod";
+var postV1WorkoutsHeaderParamsSchema = z34.object({
+  "api-key": z34.string().uuid()
+});
+var postV1Workouts201Schema = z34.lazy(() => workoutSchema);
+var postV1Workouts400Schema = z34.object({
+  error: z34.string().describe("Error message").optional()
+});
+var postV1WorkoutsMutationRequestSchema = z34.lazy(() => postWorkoutsRequestBodySchema);
+var postV1WorkoutsMutationResponseSchema = z34.lazy(() => postV1Workouts201Schema);
+
+// src/generated/client/schemas/putRoutinesRequestSetSchema.ts
+import { z as z35 } from "zod";
+var putRoutinesRequestSetSchema = z35.object({
+  type: z35.enum(["warmup", "normal", "failure", "dropset"]).describe("The type of the set.").optional(),
+  weight_kg: z35.number().describe("The weight in kilograms.").nullable().nullish(),
+  reps: z35.number().int().describe("The number of repetitions.").nullable().nullish(),
+  distance_meters: z35.number().int().describe("The distance in meters.").nullable().nullish(),
+  duration_seconds: z35.number().int().describe("The duration in seconds.").nullable().nullish(),
+  custom_metric: z35.number().describe("A custom metric for the set. Currently used for steps and floors.").nullable().nullish()
+});
+
+// src/generated/client/schemas/putRoutinesRequestExerciseSchema.ts
+import { z as z36 } from "zod";
+var putRoutinesRequestExerciseSchema = z36.object({
+  exercise_template_id: z36.string().describe("The ID of the exercise template.").optional(),
+  superset_id: z36.number().int().describe("The ID of the superset.").nullable().nullish(),
+  rest_seconds: z36.number().int().describe("The rest time in seconds.").nullable().nullish(),
+  notes: z36.string().describe("Additional notes for the exercise.").nullable().nullish(),
+  sets: z36.array(z36.lazy(() => putRoutinesRequestSetSchema)).optional()
+});
+
+// src/generated/client/schemas/putRoutinesRequestBodySchema.ts
+import { z as z37 } from "zod";
+var putRoutinesRequestBodySchema = z37.object({
+  routine: z37.object({
+    title: z37.string().describe("The title of the routine.").optional(),
+    notes: z37.string().describe("Additional notes for the routine.").nullable().nullish(),
+    exercises: z37.array(z37.lazy(() => putRoutinesRequestExerciseSchema)).optional()
+  }).optional()
+});
+
+// src/generated/client/schemas/putV1RoutinesRoutineidSchema.ts
+import { z as z38 } from "zod";
+var putV1RoutinesRoutineidPathParamsSchema = z38.object({
+  routineId: z38.any()
+});
+var putV1RoutinesRoutineidHeaderParamsSchema = z38.object({
+  "api-key": z38.string().uuid()
+});
+var putV1RoutinesRoutineid200Schema = z38.lazy(() => routineSchema);
+var putV1RoutinesRoutineid400Schema = z38.object({
+  error: z38.string().describe("Error message").optional()
+});
+var putV1RoutinesRoutineid404Schema = z38.object({
+  error: z38.string().describe("Error message").optional()
+});
+var putV1RoutinesRoutineidMutationRequestSchema = z38.lazy(() => putRoutinesRequestBodySchema);
+var putV1RoutinesRoutineidMutationResponseSchema = z38.lazy(() => putV1RoutinesRoutineid200Schema);
+
+// src/generated/client/schemas/putV1WorkoutsWorkoutidSchema.ts
+import { z as z39 } from "zod";
+var putV1WorkoutsWorkoutidPathParamsSchema = z39.object({
+  workoutId: z39.any()
+});
+var putV1WorkoutsWorkoutidHeaderParamsSchema = z39.object({
+  "api-key": z39.string().uuid()
+});
+var putV1WorkoutsWorkoutid200Schema = z39.lazy(() => workoutSchema);
+var putV1WorkoutsWorkoutid400Schema = z39.object({
+  error: z39.string().describe("Error message").optional()
+});
+var putV1WorkoutsWorkoutidMutationRequestSchema = z39.lazy(() => postWorkoutsRequestBodySchema);
+var putV1WorkoutsWorkoutidMutationResponseSchema = z39.lazy(() => putV1WorkoutsWorkoutid200Schema);
+
+// src/tools/webhooks.ts
+var webhookUrlSchema = z40.string().url().refine(
+  (url) => {
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "https:" || parsed.protocol === "http:";
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Webhook URL must be a valid HTTP or HTTPS URL"
+  }
+).refine(
+  (url) => {
+    try {
+      const parsed = new URL(url);
+      return parsed.hostname !== "localhost" && !parsed.hostname.startsWith("127.");
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Webhook URL cannot be localhost or loopback address"
+  }
+);
+function registerWebhookTools(server2, hevyClient2) {
+  server2.tool(
+    "get-webhook-subscription",
+    "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.",
+    {},
+    withErrorHandling(async () => {
+      const data = await hevyClient2.getWebhookSubscription();
+      if (!data) {
+        return createEmptyResponse(
+          "No webhook subscription found for this account"
+        );
+      }
+      return createJsonResponse(data);
+    }, "get-webhook-subscription")
+  );
+  server2.tool(
+    "create-webhook-subscription",
+    "Create a new webhook subscription for this account. The webhook will receive POST requests when workouts are created. Your endpoint must respond with 200 OK within 5 seconds.",
+    {
+      url: webhookUrlSchema.describe(
+        "The webhook URL that will receive POST requests when workouts are created"
+      ),
+      authToken: z40.string().optional().describe(
+        "Optional auth token that will be sent as Authorization header in webhook requests"
+      )
+    },
+    withErrorHandling(async ({ url, authToken }) => {
+      const requestBody = webhookRequestBodySchema.parse({
+        url,
+        authToken
+      });
+      const data = await hevyClient2.createWebhookSubscription(requestBody);
+      if (!data) {
+        return createEmptyResponse(
+          "Failed to create webhook subscription - please check your URL and try again"
+        );
+      }
+      return createJsonResponse(data);
+    }, "create-webhook-subscription")
+  );
+  server2.tool(
+    "delete-webhook-subscription",
+    "Delete the current webhook subscription for this account. This will stop all webhook notifications.",
+    {},
+    withErrorHandling(async () => {
+      const data = await hevyClient2.deleteWebhookSubscription();
+      if (!data) {
+        return createEmptyResponse(
+          "Failed to delete webhook subscription - no subscription may exist or there was a server error"
+        );
+      }
+      return createJsonResponse(data);
+    }, "delete-webhook-subscription")
+  );
+}
+
+// src/tools/workouts.ts
+import { z as z41 } from "zod";
+function registerWorkoutTools(server2, hevyClient2) {
+  server2.tool(
+    "get-workouts",
+    "Get a paginated list of workouts. Returns workout details including title, description, start/end times, and exercises performed. Results are ordered from newest to oldest.",
+    {
+      page: z41.coerce.number().gte(1).default(1),
+      pageSize: z41.coerce.number().int().gte(1).lte(10).default(5)
+    },
+    withErrorHandling(async ({ page, pageSize }) => {
+      const data = await hevyClient2.getWorkouts({
+        page,
+        pageSize
+      });
+      const workouts = data?.workouts?.map((workout) => formatWorkout(workout)) || [];
+      if (workouts.length === 0) {
+        return createEmptyResponse(
+          "No workouts found for the specified parameters"
         );
       }
       return createJsonResponse(workouts);
@@ -663,10 +1055,10 @@ function registerWorkoutTools(server2, hevyClient2) {
     "get-workout",
     "Get complete details of a specific workout by ID. Returns all workout information including title, description, start/end times, and detailed exercise data.",
     {
-      workoutId: z4.string().min(1)
+      workoutId: z41.string().min(1)
     },
     withErrorHandling(async ({ workoutId }) => {
-      const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).get();
+      const data = await hevyClient2.getWorkout(workoutId);
       if (!data) {
         return createEmptyResponse(`Workout with ID ${workoutId} not found`);
       }
@@ -679,7 +1071,7 @@ function registerWorkoutTools(server2, hevyClient2) {
     "Get the total number of workouts on the account. Useful for pagination or statistics.",
     {},
     withErrorHandling(async () => {
-      const data = await hevyClient2.v1.workouts.count.get();
+      const data = await hevyClient2.getWorkoutCount();
       const count = data ? data.workoutCount || 0 : 0;
       return createJsonResponse({ count });
     }, "get-workout-count")
@@ -688,17 +1080,15 @@ function registerWorkoutTools(server2, hevyClient2) {
     "get-workout-events",
     "Retrieve a paged list of workout events (updates or deletes) since a given date. Events are ordered from newest to oldest. The intention is to allow clients to keep their local cache of workouts up to date without having to fetch the entire list of workouts.",
     {
-      page: z4.coerce.number().int().gte(1).default(1),
-      pageSize: z4.coerce.number().int().gte(1).lte(10).default(5),
-      since: z4.string().default("1970-01-01T00:00:00Z")
+      page: z41.coerce.number().int().gte(1).default(1),
+      pageSize: z41.coerce.number().int().gte(1).lte(10).default(5),
+      since: z41.string().default("1970-01-01T00:00:00Z")
     },
     withErrorHandling(async ({ page, pageSize, since }) => {
-      const data = await hevyClient2.v1.workouts.events.get({
-        queryParameters: {
-          page,
-          pageSize,
-          since
-        }
+      const data = await hevyClient2.getWorkoutEvents({
+        page,
+        pageSize,
+        since
       });
       const events = data?.events || [];
       if (events.length === 0) {
@@ -713,25 +1103,25 @@ function registerWorkoutTools(server2, hevyClient2) {
     "create-workout",
     "Create a new workout in your Hevy account. Requires title, start/end times, and at least one exercise with sets. Returns the complete workout details upon successful creation including the newly assigned workout ID.",
     {
-      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.coerce.number().nullable().optional(),
-          notes: z4.string().optional().nullable(),
-          sets: z4.array(
-            z4.object({
-              type: z4.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-              weightKg: z4.coerce.number().optional().nullable(),
-              reps: z4.coerce.number().int().optional().nullable(),
-              distanceMeters: z4.coerce.number().int().optional().nullable(),
-              durationSeconds: z4.coerce.number().int().optional().nullable(),
-              rpe: z4.coerce.number().optional().nullable(),
-              customMetric: z4.coerce.number().optional().nullable()
+      title: z41.string().min(1),
+      description: z41.string().optional().nullable(),
+      startTime: z41.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      endTime: z41.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      isPrivate: z41.boolean().default(false),
+      exercises: z41.array(
+        z41.object({
+          exerciseTemplateId: z41.string().min(1),
+          supersetId: z41.coerce.number().nullable().optional(),
+          notes: z41.string().optional().nullable(),
+          sets: z41.array(
+            z41.object({
+              type: z41.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z41.coerce.number().optional().nullable(),
+              reps: z41.coerce.number().int().optional().nullable(),
+              distanceMeters: z41.coerce.number().int().optional().nullable(),
+              durationSeconds: z41.coerce.number().int().optional().nullable(),
+              rpe: z41.coerce.number().optional().nullable(),
+              customMetric: z41.coerce.number().optional().nullable()
             })
           )
         })
@@ -769,7 +1159,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.v1.workouts.post(requestBody);
+        const data = await hevyClient2.createWorkout(requestBody);
         if (!data) {
           return createEmptyResponse(
             "Failed to create workout: Server returned no data"
@@ -788,26 +1178,26 @@ function registerWorkoutTools(server2, hevyClient2) {
     "update-workout",
     "Update an existing workout by ID. You can modify the title, description, start/end times, privacy setting, and exercise data. Returns the updated workout with all changes applied.",
     {
-      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.coerce.number().nullable().optional(),
-          notes: z4.string().optional().nullable(),
-          sets: z4.array(
-            z4.object({
-              type: z4.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
-              weightKg: z4.coerce.number().optional().nullable(),
-              reps: z4.coerce.number().int().optional().nullable(),
-              distanceMeters: z4.coerce.number().int().optional().nullable(),
-              durationSeconds: z4.coerce.number().int().optional().nullable(),
-              rpe: z4.coerce.number().optional().nullable(),
-              customMetric: z4.coerce.number().optional().nullable()
+      workoutId: z41.string().min(1),
+      title: z41.string().min(1),
+      description: z41.string().optional().nullable(),
+      startTime: z41.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      endTime: z41.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/),
+      isPrivate: z41.boolean().default(false),
+      exercises: z41.array(
+        z41.object({
+          exerciseTemplateId: z41.string().min(1),
+          supersetId: z41.coerce.number().nullable().optional(),
+          notes: z41.string().optional().nullable(),
+          sets: z41.array(
+            z41.object({
+              type: z41.enum(["warmup", "normal", "failure", "dropset"]).default("normal"),
+              weightKg: z41.coerce.number().optional().nullable(),
+              reps: z41.coerce.number().int().optional().nullable(),
+              distanceMeters: z41.coerce.number().int().optional().nullable(),
+              durationSeconds: z41.coerce.number().int().optional().nullable(),
+              rpe: z41.coerce.number().optional().nullable(),
+              customMetric: z41.coerce.number().optional().nullable()
             })
           )
         })
@@ -846,7 +1236,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).put(requestBody);
+        const data = await hevyClient2.updateWorkout(workoutId, requestBody);
         if (!data) {
           return createEmptyResponse(
             `Failed to update workout with ID ${workoutId}`
@@ -863,1239 +1253,366 @@ function registerWorkoutTools(server2, hevyClient2) {
   );
 }
 
-// src/utils/hevyClient.ts
-import {
-  ApiKeyAuthenticationProvider,
-  ApiKeyLocation
-} from "@microsoft/kiota-abstractions";
-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/utils/hevyClientKubb.ts
+import axios from "axios";
 
-// 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();
-    }
-  };
+// src/generated/client/api/deleteV1WebhookSubscription.ts
+import fetch from "@kubb/plugin-client/clients/axios";
+function getDeleteV1WebhookSubscriptionUrl() {
+  return `/v1/webhook-subscription`;
+}
+async function deleteV1WebhookSubscription(headers, config = {}) {
+  const { client: request = fetch, ...requestConfig } = config;
+  const res = await request({
+    method: "DELETE",
+    url: getDeleteV1WebhookSubscriptionUrl().toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/getV1ExerciseTemplates.ts
+import fetch2 from "@kubb/plugin-client/clients/axios";
+function getGetV1ExerciseTemplatesUrl() {
+  return `/v1/exercise_templates`;
+}
+async function getV1ExerciseTemplates(headers, params, config = {}) {
+  const { client: request = fetch2, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1ExerciseTemplatesUrl().toString(),
+    params,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/getV1ExerciseTemplatesExercisetemplateid.ts
+import fetch3 from "@kubb/plugin-client/clients/axios";
+function getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId) {
+  return `/v1/exercise_templates/${exerciseTemplateId}`;
+}
+async function getV1ExerciseTemplatesExercisetemplateid(exerciseTemplateId, headers, config = {}) {
+  const { client: request = fetch3, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1ExerciseTemplatesExercisetemplateidUrl(exerciseTemplateId).toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function createRoutine404ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine404Error;
+
+// src/generated/client/api/getV1RoutineFolders.ts
+import fetch4 from "@kubb/plugin-client/clients/axios";
+function getGetV1RoutineFoldersUrl() {
+  return `/v1/routine_folders`;
+}
+async function getV1RoutineFolders(headers, params, config = {}) {
+  const { client: request = fetch4, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1RoutineFoldersUrl().toString(),
+    params,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoRoutine400Error(routine400Error = {}) {
-  return {
-    "error": (n) => {
-      routine400Error.errorEscaped = n.getStringValue();
-    }
-  };
+
+// src/generated/client/api/getV1RoutineFoldersFolderid.ts
+import fetch5 from "@kubb/plugin-client/clients/axios";
+function getGetV1RoutineFoldersFolderidUrl(folderId) {
+  return `/v1/routine_folders/${folderId}`;
+}
+async function getV1RoutineFoldersFolderid(folderId, headers, config = {}) {
+  const { client: request = fetch5, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1RoutineFoldersFolderidUrl(folderId).toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoRoutine404Error(routine404Error = {}) {
-  return {
-    "error": (n) => {
-      routine404Error.errorEscaped = n.getStringValue();
-    }
-  };
+
+// src/generated/client/api/getV1Routines.ts
+import fetch6 from "@kubb/plugin-client/clients/axios";
+function getGetV1RoutinesUrl() {
+  return `/v1/routines`;
+}
+async function getV1Routines(headers, params, config = {}) {
+  const { client: request = fetch6, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1RoutinesUrl().toString(),
+    params,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/getV1RoutinesRoutineid.ts
+import fetch7 from "@kubb/plugin-client/clients/axios";
+function getGetV1RoutinesRoutineidUrl(routineId) {
+  return `/v1/routines/${routineId}`;
+}
+async function getV1RoutinesRoutineid(routineId, headers, config = {}) {
+  const { client: request = fetch7, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1RoutinesRoutineidUrl(routineId).toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function createRoutine403ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine403Error;
+
+// src/generated/client/api/getV1WebhookSubscription.ts
+import fetch8 from "@kubb/plugin-client/clients/axios";
+function getGetV1WebhookSubscriptionUrl() {
+  return `/v1/webhook-subscription`;
+}
+async function getV1WebhookSubscription(headers, config = {}) {
+  const { client: request = fetch8, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1WebhookSubscriptionUrl().toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function createRoutinesGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutinesGetResponse;
+
+// src/generated/client/api/getV1Workouts.ts
+import fetch9 from "@kubb/plugin-client/clients/axios";
+function getGetV1WorkoutsUrl() {
+  return `/v1/workouts`;
+}
+async function getV1Workouts(headers, params, config = {}) {
+  const { client: request = fetch9, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1WorkoutsUrl().toString(),
+    params,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoRoutine400Error2(routine400Error = {}) {
-  return {
-    "error": (n) => {
-      routine400Error.errorEscaped = n.getStringValue();
-    }
-  };
+
+// src/generated/client/api/getV1WorkoutsCount.ts
+import fetch10 from "@kubb/plugin-client/clients/axios";
+function getGetV1WorkoutsCountUrl() {
+  return `/v1/workouts/count`;
+}
+async function getV1WorkoutsCount(headers, config = {}) {
+  const { client: request = fetch10, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1WorkoutsCountUrl().toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoRoutine403Error(routine403Error = {}) {
-  return {
-    "error": (n) => {
-      routine403Error.errorEscaped = n.getStringValue();
-    }
-  };
+
+// src/generated/client/api/getV1WorkoutsEvents.ts
+import fetch11 from "@kubb/plugin-client/clients/axios";
+function getGetV1WorkoutsEventsUrl() {
+  return `/v1/workouts/events`;
+}
+async function getV1WorkoutsEvents(headers, params, config = {}) {
+  const { client: request = fetch11, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1WorkoutsEventsUrl().toString(),
+    params,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoRoutinesGetResponse(routinesGetResponse = {}) {
-  return {
-    "page": (n) => {
-      routinesGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      routinesGetResponse.pageCount = n.getNumberValue();
-    },
-    "routines": (n) => {
-      routinesGetResponse.routines = n.getCollectionOfObjectValues(createRoutineFromDiscriminatorValue);
-    }
-  };
+
+// src/generated/client/api/getV1WorkoutsWorkoutid.ts
+import fetch12 from "@kubb/plugin-client/clients/axios";
+function getGetV1WorkoutsWorkoutidUrl(workoutId) {
+  return `/v1/workouts/${workoutId}`;
+}
+async function getV1WorkoutsWorkoutid(workoutId, headers, config = {}) {
+  const { client: request = fetch12, ...requestConfig } = config;
+  const res = await request({
+    method: "GET",
+    url: getGetV1WorkoutsWorkoutidUrl(workoutId).toString(),
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/postV1RoutineFolders.ts
+import fetch13 from "@kubb/plugin-client/clients/axios";
+function getPostV1RoutineFoldersUrl() {
+  return `/v1/routine_folders`;
+}
+async function postV1RoutineFolders(headers, data, config = {}) {
+  const { client: request = fetch13, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "POST",
+    url: getPostV1RoutineFoldersUrl().toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoCountGetResponse(countGetResponse = {}) {
-  return {
-    "workout_count": (n) => {
-      countGetResponse.workoutCount = n.getNumberValue();
-    }
-  };
+
+// src/generated/client/api/postV1Routines.ts
+import fetch14 from "@kubb/plugin-client/clients/axios";
+function getPostV1RoutinesUrl() {
+  return `/v1/routines`;
+}
+async function postV1Routines(headers, data, config = {}) {
+  const { client: request = fetch14, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "POST",
+    url: getPostV1RoutinesUrl().toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/postV1WebhookSubscription.ts
+import fetch15 from "@kubb/plugin-client/clients/axios";
+function getPostV1WebhookSubscriptionUrl() {
+  return `/v1/webhook-subscription`;
+}
+async function postV1WebhookSubscription(headers, data, config = {}) {
+  const { client: request = fetch15, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "POST",
+    url: getPostV1WebhookSubscriptionUrl().toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoWorkout400Error(workout400Error = {}) {
-  return {
-    "error": (n) => {
-      workout400Error.errorEscaped = n.getStringValue();
-    }
-  };
+
+// src/generated/client/api/postV1Workouts.ts
+import fetch16 from "@kubb/plugin-client/clients/axios";
+function getPostV1WorkoutsUrl() {
+  return `/v1/workouts`;
+}
+async function postV1Workouts(headers, data, config = {}) {
+  const { client: request = fetch16, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "POST",
+    url: getPostV1WorkoutsUrl().toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-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;
+// src/generated/client/api/putV1RoutinesRoutineid.ts
+import fetch17 from "@kubb/plugin-client/clients/axios";
+function getPutV1RoutinesRoutineidUrl(routineId) {
+  return `/v1/routines/${routineId}`;
+}
+async function putV1RoutinesRoutineid(routineId, headers, data, config = {}) {
+  const { client: request = fetch17, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "PUT",
+    url: getPutV1RoutinesRoutineidUrl(routineId).toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function createWorkoutsGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoWorkoutsGetResponse;
+
+// src/generated/client/api/putV1WorkoutsWorkoutid.ts
+import fetch18 from "@kubb/plugin-client/clients/axios";
+function getPutV1WorkoutsWorkoutidUrl(workoutId) {
+  return `/v1/workouts/${workoutId}`;
+}
+async function putV1WorkoutsWorkoutid(workoutId, headers, data, config = {}) {
+  const { client: request = fetch18, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({
+    method: "PUT",
+    url: getPutV1WorkoutsWorkoutidUrl(workoutId).toString(),
+    data: requestData,
+    ...requestConfig,
+    headers: { ...headers, ...requestConfig.headers }
+  });
+  return res.data;
 }
-function deserializeIntoWorkout400Error2(workout400Error = {}) {
-  return {
-    "error": (n) => {
-      workout400Error.errorEscaped = n.getStringValue();
+
+// src/utils/hevyClientKubb.ts
+function createClient(apiKey2, baseUrl = "https://api.hevyapp.com") {
+  const axiosInstance = axios.create({
+    baseURL: baseUrl,
+    headers: {
+      "api-key": apiKey2
     }
+  });
+  const headers = {
+    "api-key": apiKey2
   };
-}
-function deserializeIntoWorkoutsGetResponse(workoutsGetResponse = {}) {
+  const client = axiosInstance;
   return {
-    "page": (n) => {
-      workoutsGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      workoutsGetResponse.pageCount = n.getNumberValue();
-    },
-    "workouts": (n) => {
-      workoutsGetResponse.workouts = n.getCollectionOfObjectValues(createWorkoutFromDiscriminatorValue);
-    }
+    // Workouts
+    getWorkouts: (params) => getV1Workouts(headers, params, { client }),
+    getWorkout: (workoutId) => getV1WorkoutsWorkoutid(workoutId, headers, { client }),
+    createWorkout: (data) => postV1Workouts(headers, data, { client }),
+    updateWorkout: (workoutId, data) => putV1WorkoutsWorkoutid(workoutId, headers, data, {
+      client
+    }),
+    getWorkoutCount: () => getV1WorkoutsCount(headers, { client }),
+    getWorkoutEvents: (params) => getV1WorkoutsEvents(headers, params, { client }),
+    // Routines
+    getRoutines: (params) => getV1Routines(headers, params, { client }),
+    getRoutineById: (routineId) => getV1RoutinesRoutineid(routineId, headers, { client }),
+    createRoutine: (data) => postV1Routines(headers, data, { client }),
+    updateRoutine: (routineId, data) => putV1RoutinesRoutineid(routineId, headers, data, {
+      client
+    }),
+    // Exercise Templates
+    getExerciseTemplates: (params) => getV1ExerciseTemplates(headers, params, { client }),
+    getExerciseTemplate: (templateId) => getV1ExerciseTemplatesExercisetemplateid(templateId, headers, {
+      client
+    }),
+    // Routine Folders
+    getRoutineFolders: (params) => getV1RoutineFolders(headers, params, { client }),
+    createRoutineFolder: (data) => postV1RoutineFolders(headers, data, { client }),
+    getRoutineFolder: (folderId) => getV1RoutineFoldersFolderid(folderId, headers, {
+      client
+    }),
+    // Webhooks
+    getWebhookSubscription: () => getV1WebhookSubscription(headers, { client }),
+    createWebhookSubscription: (data) => postV1WebhookSubscription(headers, data, { client }),
+    deleteWebhookSubscription: () => deleteV1WebhookSubscription(headers, { client })
   };
 }
-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, ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry } 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) {
-  if (requestAdapter === void 0) {
-    throw new Error("requestAdapter cannot be undefined");
-  }
-  let serializationWriterFactory;
-  let parseNodeFactoryRegistry;
-  if (requestAdapter.getParseNodeFactory() instanceof ParseNodeFactoryRegistry) {
-    parseNodeFactoryRegistry = requestAdapter.getParseNodeFactory();
-  } else {
-    throw new Error("requestAdapter.getParseNodeFactory() is not a ParseNodeFactoryRegistry");
-  }
-  if (requestAdapter.getSerializationWriterFactory() instanceof SerializationWriterFactoryRegistry) {
-    serializationWriterFactory = requestAdapter.getSerializationWriterFactory();
-  } else {
-    throw new Error("requestAdapter.getSerializationWriterFactory() is not a SerializationWriterFactoryRegistry");
-  }
-  serializationWriterFactory.registerDefaultSerializer(JsonSerializationWriterFactory);
-  serializationWriterFactory.registerDefaultSerializer(TextSerializationWriterFactory);
-  serializationWriterFactory.registerDefaultSerializer(FormSerializationWriterFactory);
-  serializationWriterFactory.registerDefaultSerializer(MultipartSerializationWriterFactory);
-  const backingStoreFactory = requestAdapter.getBackingStoreFactory();
-  parseNodeFactoryRegistry.registerDefaultDeserializer(JsonParseNodeFactory, backingStoreFactory);
-  parseNodeFactoryRegistry.registerDefaultDeserializer(TextParseNodeFactory, backingStoreFactory);
-  parseNodeFactoryRegistry.registerDefaultDeserializer(FormParseNodeFactory, backingStoreFactory);
-  const pathParameters = {
-    "baseurl": requestAdapter.baseUrl
-  };
-  return apiClientProxifier(requestAdapter, pathParameters, HevyClientNavigationMetadata, void 0);
-}
-var HevyClientNavigationMetadata = {
-  v1: {
-    navigationMetadata: V1RequestBuilderNavigationMetadata
-  }
-};
 
 // src/utils/hevyClient.ts
-function createClient(apiKey2, baseUrl) {
-  const authProvider = new ApiKeyAuthenticationProvider(
-    apiKey2,
-    "api-key",
-    ApiKeyLocation.Header
-  );
-  const adapter = new FetchRequestAdapter(authProvider);
-  adapter.baseUrl = baseUrl;
-  return createHevyClient(adapter);
+function createClient2(apiKey2, baseUrl) {
+  return createClient(apiKey2, baseUrl);
 }
 
-// package.json
-var name = "hevy-mcp";
-var version = "1.3.1";
-
 // src/index.ts
 var HEVY_API_BASEURL = "https://api.hevyapp.com";
 var server = new McpServer({
@@ -2107,11 +1624,12 @@ if (!process.env.HEVY_API_KEY) {
   process.exit(1);
 }
 var apiKey = process.env.HEVY_API_KEY || "";
-var hevyClient = createClient(apiKey, HEVY_API_BASEURL);
+var hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
 registerWorkoutTools(server, hevyClient);
 registerRoutineTools(server, hevyClient);
 registerTemplateTools(server, hevyClient);
 registerFolderTools(server, hevyClient);
+registerWebhookTools(server, hevyClient);
 async function runServer() {
   const transport = new StdioServerTransport();
   await server.connect(transport);