hevy-mcp 1.0.0 → 1.0.1

package/dist/index.js

@@ -867,8 +867,455 @@ function calculateDuration(startTime, endTime) {
 }
 
 // src/utils/hevyClient.ts
+import {
+  ApiKeyAuthenticationProvider,
+  ApiKeyLocation
+} from "@microsoft/kiota-abstractions";
 import { FetchRequestAdapter } from "@microsoft/kiota-http-fetchlibrary";
 
+// src/generated/client/hevyClient.ts
+import {
+  apiClientProxifier,
+  registerDefaultDeserializer,
+  registerDefaultSerializer
+} from "@microsoft/kiota-abstractions";
+
+// ../node_modules/@microsoft/kiota-serialization-form/dist/es/src/formParseNode.js
+import { createBackedModelProxyHandler, DateOnly, Duration, parseGuidString, TimeOnly, isBackingStoreEnabled, getEnumValueFromStringValue } from "@microsoft/kiota-abstractions";
+var FormParseNode = class _FormParseNode {
+  /**
+   *  Creates a new instance of FormParseNode
+   * @param _rawString the raw string to parse
+   * @param backingStoreFactory the factory to create backing stores
+   */
+  constructor(_rawString, backingStoreFactory) {
+    this._rawString = _rawString;
+    this.backingStoreFactory = backingStoreFactory;
+    this._fields = {};
+    this.normalizeKey = (key) => decodeURIComponent(key).trim();
+    this.getStringValue = () => decodeURIComponent(this._rawString);
+    this.getChildNode = (identifier) => {
+      if (this._fields[identifier]) {
+        return new _FormParseNode(this._fields[identifier], this.backingStoreFactory);
+      }
+      return void 0;
+    };
+    this.getBooleanValue = () => {
+      var _a;
+      const value = (_a = this.getStringValue()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+      if (value === "true" || value === "1") {
+        return true;
+      } else if (value === "false" || value === "0") {
+        return false;
+      }
+      return void 0;
+    };
+    this.getNumberValue = () => parseFloat(this.getStringValue());
+    this.getGuidValue = () => parseGuidString(this.getStringValue());
+    this.getDateValue = () => new Date(Date.parse(this.getStringValue()));
+    this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
+    this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
+    this.getDurationValue = () => Duration.parse(this.getStringValue());
+    this.getCollectionOfPrimitiveValues = () => {
+      return this._rawString.split(",").map((x) => {
+        const currentParseNode = new _FormParseNode(x, this.backingStoreFactory);
+        const typeOfX = typeof x;
+        if (typeOfX === "boolean") {
+          return currentParseNode.getBooleanValue();
+        } else if (typeOfX === "string") {
+          return currentParseNode.getStringValue();
+        } else if (typeOfX === "number") {
+          return currentParseNode.getNumberValue();
+        } else if (x instanceof Date) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof DateOnly) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof TimeOnly) {
+          return currentParseNode.getDateValue();
+        } else if (x instanceof Duration) {
+          return currentParseNode.getDateValue();
+        } else {
+          throw new Error(`encountered an unknown type during deserialization ${typeof x}`);
+        }
+      });
+    };
+    this.getCollectionOfObjectValues = (parsableFactory) => {
+      throw new Error(`serialization of collections is not supported with URI encoding`);
+    };
+    this.getObjectValue = (parsableFactory) => {
+      const temp = {};
+      const enableBackingStore = isBackingStoreEnabled(parsableFactory(this)(temp));
+      const value = enableBackingStore && this.backingStoreFactory ? new Proxy(temp, createBackedModelProxyHandler(this.backingStoreFactory)) : temp;
+      if (this.onBeforeAssignFieldValues) {
+        this.onBeforeAssignFieldValues(value);
+      }
+      this.assignFieldValues(value, parsableFactory);
+      if (this.onAfterAssignFieldValues) {
+        this.onAfterAssignFieldValues(value);
+      }
+      return value;
+    };
+    this.getCollectionOfEnumValues = (type) => {
+      const rawValues = this.getStringValue();
+      if (!rawValues) {
+        return [];
+      }
+      return rawValues.split(",").map((x) => getEnumValueFromStringValue(x, type));
+    };
+    this.getEnumValue = (type) => {
+      const rawValue = this.getStringValue();
+      if (!rawValue) {
+        return void 0;
+      }
+      return getEnumValueFromStringValue(rawValue, type);
+    };
+    this.assignFieldValues = (model, parsableFactory) => {
+      const fields = parsableFactory(this)(model);
+      Object.entries(this._fields).filter((x) => !/^null$/i.test(x[1])).forEach(([k, v]) => {
+        const deserializer = fields[k];
+        if (deserializer) {
+          deserializer(new _FormParseNode(v, this.backingStoreFactory));
+        } else {
+          model[k] = v;
+        }
+      });
+    };
+    if (!_rawString) {
+      throw new Error("rawString cannot be undefined");
+    }
+    _rawString.split("&").map((x) => x.split("=")).filter((x) => x.length === 2).forEach((x) => {
+      const key = this.normalizeKey(x[0]);
+      if (this._fields[key]) {
+        this._fields[key] += "," + x[1];
+      } else {
+        this._fields[key] = x[1];
+      }
+    });
+  }
+  getByteArrayValue() {
+    throw new Error("serialization of byt arrays is not supported with URI encoding");
+  }
+};
+
+// ../node_modules/@microsoft/kiota-serialization-form/dist/es/src/formSerializationWriter.js
+import { DateOnly as DateOnly2, Duration as Duration2, TimeOnly as TimeOnly2 } from "@microsoft/kiota-abstractions";
+var FormSerializationWriter = class _FormSerializationWriter {
+  constructor() {
+    this.writer = [];
+    this.depth = -1;
+    this.writeStringValue = (key, value) => {
+      if (value === null) {
+        value = "null";
+      }
+      if (key && value) {
+        this.writePropertyName(key);
+        this.writer.push(`=${encodeURIComponent(value)}`);
+        this.writer.push(_FormSerializationWriter.propertySeparator);
+      }
+    };
+    this.writePropertyName = (key) => {
+      this.writer.push(encodeURIComponent(key));
+    };
+    this.shouldWriteValueOrNull = (key, value) => {
+      if (value === null) {
+        this.writeNullValue(key);
+        return false;
+      }
+      return true;
+    };
+    this.writeBooleanValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value !== void 0 && this.writeStringValue(key, `${value}`);
+      }
+    };
+    this.writeNumberValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, `${value}`);
+      }
+    };
+    this.writeGuidValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeDateValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toISOString());
+      }
+    };
+    this.writeDateOnlyValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeTimeOnlyValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeDurationValue = (key, value) => {
+      if (this.shouldWriteValueOrNull(key, value)) {
+        value && this.writeStringValue(key, value.toString());
+      }
+    };
+    this.writeNullValue = (key) => {
+      key && this.writeStringValue(key, null);
+    };
+    this.writeCollectionOfPrimitiveValues = (_key, _values) => {
+      if (_key && _values) {
+        _values.forEach((val) => {
+          this.writeAnyValue(_key, val);
+        });
+      }
+    };
+    this.writeCollectionOfObjectValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with URI encoding`);
+    };
+    this.writeObjectValue = (key, value, serializerMethod) => {
+      if (++this.depth > 0) {
+        throw new Error(`serialization of nested objects is not supported with URI encoding`);
+      }
+      if (!this.shouldWriteValueOrNull(key, value)) {
+        return;
+      }
+      if (value) {
+        if (key) {
+          this.writePropertyName(key);
+        }
+        this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
+        this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+        serializerMethod(this, value);
+        this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+        if (this.writer.length > 0 && this.writer[this.writer.length - 1] === _FormSerializationWriter.propertySeparator) {
+          this.writer.pop();
+        }
+        key && this.writer.push(_FormSerializationWriter.propertySeparator);
+      }
+    };
+    this.writeEnumValue = (key, ...values) => {
+      if (values.length > 0) {
+        const rawValues = values.filter((x) => x !== void 0).map((x) => `${x}`);
+        if (rawValues.length > 0) {
+          this.writeStringValue(key, rawValues.reduce((x, y) => `${x}, ${y}`));
+        }
+      }
+    };
+    this.writeCollectionOfEnumValues = (key, values) => {
+      if (key && values && values.length > 0) {
+        const rawValues = values.filter((x) => x !== void 0).map((x) => `${x}`);
+        if (rawValues.length > 0) {
+          this.writeCollectionOfPrimitiveValues(key, rawValues);
+        }
+      }
+    };
+    this.getSerializedContent = () => {
+      return this.convertStringToArrayBuffer(this.writer.join(``));
+    };
+    this.convertStringToArrayBuffer = (str) => {
+      const encoder = new TextEncoder();
+      const encodedString = encoder.encode(str);
+      return encodedString.buffer;
+    };
+    this.writeAdditionalData = (additionalData) => {
+      if (additionalData === void 0)
+        return;
+      for (const key in additionalData) {
+        this.writeAnyValue(key, additionalData[key]);
+      }
+    };
+    this.writeAnyValue = (key, value) => {
+      if (value === null) {
+        return this.writeNullValue(key);
+      }
+      if (value !== void 0) {
+        const valueType = typeof value;
+        if (valueType === "boolean") {
+          this.writeBooleanValue(key, value);
+        } else if (valueType === "string") {
+          this.writeStringValue(key, value);
+        } else if (value instanceof Date) {
+          this.writeDateValue(key, value);
+        } else if (value instanceof DateOnly2) {
+          this.writeDateOnlyValue(key, value);
+        } else if (value instanceof TimeOnly2) {
+          this.writeTimeOnlyValue(key, value);
+        } else if (value instanceof Duration2) {
+          this.writeDurationValue(key, value);
+        } else if (valueType === "number") {
+          this.writeNumberValue(key, value);
+        } else {
+          throw new Error(`encountered unknown ${value} value type during serialization ${valueType} for key ${key}`);
+        }
+      }
+    };
+  }
+  writeByteArrayValue(key, value) {
+    throw new Error("serialization of byt arrays is not supported with URI encoding");
+  }
+};
+FormSerializationWriter.propertySeparator = `&`;
+
+// ../node_modules/@microsoft/kiota-serialization-form/dist/es/src/formParseNodeFactory.js
+var FormParseNodeFactory = class {
+  /**
+   * Creates an instance of JsonParseNode.
+   * @param backingStoreFactory - The factory to create backing stores.
+   */
+  constructor(backingStoreFactory) {
+    this.backingStoreFactory = backingStoreFactory;
+  }
+  getValidContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+  getRootParseNode(contentType, content) {
+    if (!content) {
+      throw new Error("content cannot be undefined of empty");
+    } else if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new FormParseNode(this.convertArrayBufferToString(content), this.backingStoreFactory);
+  }
+  convertArrayBufferToString(content) {
+    const decoder = new TextDecoder();
+    return decoder.decode(content);
+  }
+};
+
+// ../node_modules/@microsoft/kiota-serialization-form/dist/es/src/formSerializationWriterFactory.js
+var FormSerializationWriterFactory = class {
+  getValidContentType() {
+    return "application/x-www-form-urlencoded";
+  }
+  getSerializationWriter(contentType) {
+    if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new FormSerializationWriter();
+  }
+};
+
+// src/generated/client/hevyClient.ts
+import {
+  JsonParseNodeFactory,
+  JsonSerializationWriterFactory
+} from "@microsoft/kiota-serialization-json";
+
+// ../node_modules/@microsoft/kiota-serialization-multipart/dist/es/src/multipartSerializationWriter.js
+import { MultipartBody } from "@microsoft/kiota-abstractions";
+var MultipartSerializationWriter = class {
+  constructor() {
+    this.writer = new ArrayBuffer(0);
+    this.writeStringValue = (key, value) => {
+      if (key) {
+        this.writeRawStringValue(key);
+      }
+      if (value) {
+        if (key) {
+          this.writeRawStringValue(": ");
+        }
+        this.writeRawStringValue(value);
+      }
+    };
+    this.writeRawStringValue = (value) => {
+      if (value) {
+        this.writeByteArrayValue(void 0, new TextEncoder().encode(value).buffer);
+      }
+    };
+    this.writeBooleanValue = (key, value) => {
+      throw new Error(`serialization of boolean values is not supported with multipart`);
+    };
+    this.writeNumberValue = (key, value) => {
+      throw new Error(`serialization of number values is not supported with multipart`);
+    };
+    this.writeGuidValue = (key, value) => {
+      throw new Error(`serialization of guid values is not supported with multipart`);
+    };
+    this.writeDateValue = (key, value) => {
+      throw new Error(`serialization of date values is not supported with multipart`);
+    };
+    this.writeDateOnlyValue = (key, value) => {
+      throw new Error(`serialization of date only values is not supported with multipart`);
+    };
+    this.writeTimeOnlyValue = (key, value) => {
+      throw new Error(`serialization of time only values is not supported with multipart`);
+    };
+    this.writeDurationValue = (key, value) => {
+      throw new Error(`serialization of duration values is not supported with multipart`);
+    };
+    this.writeNullValue = (key) => {
+      throw new Error(`serialization of null values is not supported with multipart`);
+    };
+    this.writeCollectionOfPrimitiveValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with multipart`);
+    };
+    this.writeCollectionOfObjectValues = (_key, _values) => {
+      throw new Error(`serialization of collections is not supported with multipart`);
+    };
+    this.writeObjectValue = (key, value, serializerMethod) => {
+      if (!value) {
+        throw new Error(`value cannot be undefined`);
+      }
+      if (!(value instanceof MultipartBody)) {
+        throw new Error(`expected MultipartBody instance`);
+      }
+      if (!serializerMethod) {
+        throw new Error(`serializer method cannot be undefined`);
+      }
+      this.onBeforeObjectSerialization && this.onBeforeObjectSerialization(value);
+      this.onStartObjectSerialization && this.onStartObjectSerialization(value, this);
+      serializerMethod(this, value);
+      this.onAfterObjectSerialization && this.onAfterObjectSerialization(value);
+    };
+    this.writeEnumValue = (key, ...values) => {
+      throw new Error(`serialization of enum values is not supported with multipart`);
+    };
+    this.writeCollectionOfEnumValues = (key, values) => {
+      throw new Error(`serialization of collection of enum values is not supported with multipart`);
+    };
+    this.getSerializedContent = () => {
+      return this.writer;
+    };
+    this.writeAdditionalData = (additionalData) => {
+      throw new Error(`serialization of additional data is not supported with multipart`);
+    };
+  }
+  writeByteArrayValue(key, value) {
+    if (!value) {
+      throw new Error("value cannot be undefined");
+    }
+    const previousValue = this.writer;
+    this.writer = new ArrayBuffer(previousValue.byteLength + value.byteLength);
+    const pipe = new Uint8Array(this.writer);
+    pipe.set(new Uint8Array(previousValue), 0);
+    pipe.set(new Uint8Array(value), previousValue.byteLength);
+  }
+};
+
+// ../node_modules/@microsoft/kiota-serialization-multipart/dist/es/src/multipartSerializationWriterFactory.js
+var MultipartSerializationWriterFactory = class {
+  getValidContentType() {
+    return "multipart/form-data";
+  }
+  getSerializationWriter(contentType) {
+    if (!contentType) {
+      throw new Error("content type cannot be undefined or empty");
+    } else if (this.getValidContentType() !== contentType) {
+      throw new Error(`expected a ${this.getValidContentType()} content type`);
+    }
+    return new MultipartSerializationWriter();
+  }
+};
+
+// src/generated/client/hevyClient.ts
+import {
+  TextParseNodeFactory,
+  TextSerializationWriterFactory
+} from "@microsoft/kiota-serialization-text";
+
 // src/generated/client/models/index.ts
 function createDeletedWorkoutFromDiscriminatorValue(parseNode) {
   return deserializeIntoDeletedWorkout;
@@ -905,253 +1352,287 @@ function createWorkoutFromDiscriminatorValue(parseNode) {
 }
 function deserializeIntoDeletedWorkout(deletedWorkout = {}) {
   return {
-    "deleted_at": (n) => {
+    deleted_at: (n) => {
       deletedWorkout.deletedAt = n.getStringValue();
     },
-    "id": (n) => {
+    id: (n) => {
       deletedWorkout.id = n.getStringValue();
     },
-    "type": (n) => {
+    type: (n) => {
       deletedWorkout.type = n.getStringValue();
     }
   };
 }
 function deserializeIntoExerciseTemplate(exerciseTemplate = {}) {
   return {
-    "id": (n) => {
+    id: (n) => {
       exerciseTemplate.id = n.getStringValue();
     },
-    "is_custom": (n) => {
+    is_custom: (n) => {
       exerciseTemplate.isCustom = n.getBooleanValue();
     },
-    "primary_muscle_group": (n) => {
+    primary_muscle_group: (n) => {
       exerciseTemplate.primaryMuscleGroup = n.getStringValue();
     },
-    "secondary_muscle_groups": (n) => {
+    secondary_muscle_groups: (n) => {
       exerciseTemplate.secondaryMuscleGroups = n.getCollectionOfPrimitiveValues();
     },
-    "title": (n) => {
+    title: (n) => {
       exerciseTemplate.title = n.getStringValue();
     },
-    "type": (n) => {
+    type: (n) => {
       exerciseTemplate.type = n.getStringValue();
     }
   };
 }
 function deserializeIntoPaginatedWorkoutEvents(paginatedWorkoutEvents = {}) {
   return {
-    "events": (n) => {
-      paginatedWorkoutEvents.events = n.getCollectionOfObjectValues(createDeletedWorkoutFromDiscriminatorValue) ?? n.getCollectionOfObjectValues(createUpdatedWorkoutFromDiscriminatorValue);
-    },
-    "page": (n) => {
+    events: (n) => {
+      paginatedWorkoutEvents.events = n.getCollectionOfObjectValues(
+        createDeletedWorkoutFromDiscriminatorValue
+      ) ?? n.getCollectionOfObjectValues(
+        createUpdatedWorkoutFromDiscriminatorValue
+      );
+    },
+    page: (n) => {
       paginatedWorkoutEvents.page = n.getNumberValue();
     },
-    "page_count": (n) => {
+    page_count: (n) => {
       paginatedWorkoutEvents.pageCount = n.getNumberValue();
     }
   };
 }
 function deserializeIntoRoutine(routine = {}) {
   return {
-    "created_at": (n) => {
+    created_at: (n) => {
       routine.createdAt = n.getStringValue();
     },
-    "exercises": (n) => {
-      routine.exercises = n.getCollectionOfObjectValues(createRoutine_exercisesFromDiscriminatorValue);
+    exercises: (n) => {
+      routine.exercises = n.getCollectionOfObjectValues(
+        createRoutine_exercisesFromDiscriminatorValue
+      );
     },
-    "folder_id": (n) => {
+    folder_id: (n) => {
       routine.folderId = n.getNumberValue();
     },
-    "id": (n) => {
+    id: (n) => {
       routine.id = n.getStringValue();
     },
-    "title": (n) => {
+    title: (n) => {
       routine.title = n.getStringValue();
     },
-    "updated_at": (n) => {
+    updated_at: (n) => {
       routine.updatedAt = n.getStringValue();
     }
   };
 }
 function deserializeIntoRoutine_exercises(routine_exercises = {}) {
   return {
-    "exercise_template_id": (n) => {
+    exercise_template_id: (n) => {
       routine_exercises.exerciseTemplateId = n.getStringValue();
     },
-    "index": (n) => {
+    index: (n) => {
       routine_exercises.index = n.getNumberValue();
     },
-    "notes": (n) => {
+    notes: (n) => {
       routine_exercises.notes = n.getStringValue();
     },
-    "sets": (n) => {
-      routine_exercises.sets = n.getCollectionOfObjectValues(createRoutine_exercises_setsFromDiscriminatorValue);
+    sets: (n) => {
+      routine_exercises.sets = n.getCollectionOfObjectValues(
+        createRoutine_exercises_setsFromDiscriminatorValue
+      );
     },
-    "supersets_id": (n) => {
+    supersets_id: (n) => {
       routine_exercises.supersetsId = n.getNumberValue();
     },
-    "title": (n) => {
+    title: (n) => {
       routine_exercises.title = n.getStringValue();
     }
   };
 }
 function deserializeIntoRoutine_exercises_sets(routine_exercises_sets = {}) {
   return {
-    "custom_metric": (n) => {
+    custom_metric: (n) => {
       routine_exercises_sets.customMetric = n.getNumberValue();
     },
-    "distance_meters": (n) => {
+    distance_meters: (n) => {
       routine_exercises_sets.distanceMeters = n.getNumberValue();
     },
-    "duration_seconds": (n) => {
+    duration_seconds: (n) => {
       routine_exercises_sets.durationSeconds = n.getNumberValue();
     },
-    "index": (n) => {
+    index: (n) => {
       routine_exercises_sets.index = n.getNumberValue();
     },
-    "reps": (n) => {
+    reps: (n) => {
       routine_exercises_sets.reps = n.getNumberValue();
     },
-    "rpe": (n) => {
+    rpe: (n) => {
       routine_exercises_sets.rpe = n.getNumberValue();
     },
-    "type": (n) => {
+    type: (n) => {
       routine_exercises_sets.type = n.getStringValue();
     },
-    "weight_kg": (n) => {
+    weight_kg: (n) => {
       routine_exercises_sets.weightKg = n.getNumberValue();
     }
   };
 }
 function deserializeIntoRoutineFolder(routineFolder = {}) {
   return {
-    "created_at": (n) => {
+    created_at: (n) => {
       routineFolder.createdAt = n.getStringValue();
     },
-    "id": (n) => {
+    id: (n) => {
       routineFolder.id = n.getNumberValue();
     },
-    "index": (n) => {
+    index: (n) => {
       routineFolder.index = n.getNumberValue();
     },
-    "title": (n) => {
+    title: (n) => {
       routineFolder.title = n.getStringValue();
     },
-    "updated_at": (n) => {
+    updated_at: (n) => {
       routineFolder.updatedAt = n.getStringValue();
     }
   };
 }
 function deserializeIntoUpdatedWorkout(updatedWorkout = {}) {
   return {
-    "type": (n) => {
+    type: (n) => {
       updatedWorkout.type = n.getStringValue();
     },
-    "workout": (n) => {
-      updatedWorkout.workout = n.getObjectValue(createWorkoutFromDiscriminatorValue);
+    workout: (n) => {
+      updatedWorkout.workout = n.getObjectValue(
+        createWorkoutFromDiscriminatorValue
+      );
     }
   };
 }
 function deserializeIntoWorkout(workout = {}) {
   return {
-    "created_at": (n) => {
+    created_at: (n) => {
       workout.createdAt = n.getStringValue();
     },
-    "description": (n) => {
+    description: (n) => {
       workout.description = n.getStringValue();
     },
-    "end_time": (n) => {
+    end_time: (n) => {
       workout.endTime = n.getNumberValue();
     },
-    "exercises": (n) => {
-      workout.exercises = n.getCollectionOfObjectValues(createWorkout_exercisesFromDiscriminatorValue);
+    exercises: (n) => {
+      workout.exercises = n.getCollectionOfObjectValues(
+        createWorkout_exercisesFromDiscriminatorValue
+      );
     },
-    "id": (n) => {
+    id: (n) => {
       workout.id = n.getStringValue();
     },
-    "start_time": (n) => {
+    start_time: (n) => {
       workout.startTime = n.getNumberValue();
     },
-    "title": (n) => {
+    title: (n) => {
       workout.title = n.getStringValue();
     },
-    "updated_at": (n) => {
+    updated_at: (n) => {
       workout.updatedAt = n.getStringValue();
     }
   };
 }
 function deserializeIntoWorkout_exercises(workout_exercises = {}) {
   return {
-    "exercise_template_id": (n) => {
+    exercise_template_id: (n) => {
       workout_exercises.exerciseTemplateId = n.getStringValue();
     },
-    "index": (n) => {
+    index: (n) => {
       workout_exercises.index = n.getNumberValue();
     },
-    "notes": (n) => {
+    notes: (n) => {
       workout_exercises.notes = n.getStringValue();
     },
-    "sets": (n) => {
-      workout_exercises.sets = n.getCollectionOfObjectValues(createWorkout_exercises_setsFromDiscriminatorValue);
+    sets: (n) => {
+      workout_exercises.sets = n.getCollectionOfObjectValues(
+        createWorkout_exercises_setsFromDiscriminatorValue
+      );
     },
-    "supersets_id": (n) => {
+    supersets_id: (n) => {
       workout_exercises.supersetsId = n.getNumberValue();
     },
-    "title": (n) => {
+    title: (n) => {
       workout_exercises.title = n.getStringValue();
     }
   };
 }
 function deserializeIntoWorkout_exercises_sets(workout_exercises_sets = {}) {
   return {
-    "custom_metric": (n) => {
+    custom_metric: (n) => {
       workout_exercises_sets.customMetric = n.getNumberValue();
     },
-    "distance_meters": (n) => {
+    distance_meters: (n) => {
       workout_exercises_sets.distanceMeters = n.getNumberValue();
     },
-    "duration_seconds": (n) => {
+    duration_seconds: (n) => {
       workout_exercises_sets.durationSeconds = n.getNumberValue();
     },
-    "index": (n) => {
+    index: (n) => {
       workout_exercises_sets.index = n.getNumberValue();
     },
-    "reps": (n) => {
+    reps: (n) => {
       workout_exercises_sets.reps = n.getNumberValue();
     },
-    "rpe": (n) => {
+    rpe: (n) => {
       workout_exercises_sets.rpe = n.getNumberValue();
     },
-    "type": (n) => {
+    type: (n) => {
       workout_exercises_sets.type = n.getStringValue();
     },
-    "weight_kg": (n) => {
+    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.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);
+    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.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.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);
@@ -1159,72 +1640,147 @@ function serializePostRoutinesRequestBody_routine(writer, postRoutinesRequestBod
 }
 function serializePostRoutinesRequestExercise(writer, postRoutinesRequestExercise = {}) {
   if (postRoutinesRequestExercise) {
-    writer.writeStringValue("exercise_template_id", postRoutinesRequestExercise.exerciseTemplateId);
+    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.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(
+      "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.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.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(
+      "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(
+      "exercise_template_id",
+      postWorkoutsRequestExercise.exerciseTemplateId
+    );
     writer.writeStringValue("notes", postWorkoutsRequestExercise.notes);
-    writer.writeCollectionOfObjectValues("sets", postWorkoutsRequestExercise.sets, serializePostWorkoutsRequestSet);
-    writer.writeNumberValue("superset_id", postWorkoutsRequestExercise.supersetId);
+    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(
+      "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.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.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.writeCollectionOfObjectValues(
+      "exercises",
+      putRoutinesRequestBody_routine.exercises,
+      serializePutRoutinesRequestExercise
+    );
     writer.writeStringValue("notes", putRoutinesRequestBody_routine.notes);
     writer.writeStringValue("title", putRoutinesRequestBody_routine.title);
     writer.writeAdditionalData(putRoutinesRequestBody_routine.additionalData);
@@ -1232,818 +1788,420 @@ function serializePutRoutinesRequestBody_routine(writer, putRoutinesRequestBody_
 }
 function serializePutRoutinesRequestExercise(writer, putRoutinesRequestExercise = {}) {
   if (putRoutinesRequestExercise) {
-    writer.writeStringValue("exercise_template_id", putRoutinesRequestExercise.exerciseTemplateId);
+    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.writeNumberValue(
+      "rest_seconds",
+      putRoutinesRequestExercise.restSeconds
+    );
+    writer.writeCollectionOfObjectValues(
+      "sets",
+      putRoutinesRequestExercise.sets,
+      serializePutRoutinesRequestSet
+    );
+    writer.writeNumberValue(
+      "superset_id",
+      putRoutinesRequestExercise.supersetId
+    );
     writer.writeAdditionalData(putRoutinesRequestExercise.additionalData);
   }
 }
 function serializePutRoutinesRequestSet(writer, putRoutinesRequestSet = {}) {
   if (putRoutinesRequestSet) {
-    writer.writeNumberValue("custom_metric", putRoutinesRequestSet.customMetric);
-    writer.writeNumberValue("distance_meters", putRoutinesRequestSet.distanceMeters);
-    writer.writeNumberValue("duration_seconds", putRoutinesRequestSet.durationSeconds);
-    writer.writeNumberValue("reps", putRoutinesRequestSet.reps);
-    writer.writeEnumValue("type", putRoutinesRequestSet.type);
-    writer.writeNumberValue("weight_kg", putRoutinesRequestSet.weightKg);
-    writer.writeAdditionalData(putRoutinesRequestSet.additionalData);
-  }
-}
-
-// src/generated/client/v1/exercise_templates/item/index.ts
-var WithExerciseTemplateItemRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates/{exerciseTemplateId}";
-var WithExerciseTemplateItemRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: WithExerciseTemplateItemRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createExerciseTemplateFromDiscriminatorValue
-  }
-};
-
-// src/generated/client/v1/exercise_templates/index.ts
-function createExercise_templatesGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoExercise_templatesGetResponse;
-}
-function deserializeIntoExercise_templatesGetResponse(exercise_templatesGetResponse = {}) {
-  return {
-    "exercise_templates": (n) => {
-      exercise_templatesGetResponse.exerciseTemplates = n.getCollectionOfObjectValues(createExerciseTemplateFromDiscriminatorValue);
-    },
-    "page": (n) => {
-      exercise_templatesGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      exercise_templatesGetResponse.pageCount = n.getNumberValue();
-    }
-  };
-}
-var Exercise_templatesRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates{?page*,pageSize*}";
-var Exercise_templatesRequestBuilderNavigationMetadata = {
-  byExerciseTemplateId: {
-    requestsMetadata: WithExerciseTemplateItemRequestBuilderRequestsMetadata,
-    pathParametersMappings: ["exerciseTemplateId"]
-  }
-};
-var Exercise_templatesRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: Exercise_templatesRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createExercise_templatesGetResponseFromDiscriminatorValue
-  }
-};
-
-// src/generated/client/v1/routine_folders/item/index.ts
-var WithFolderItemRequestBuilderUriTemplate = "{+baseurl}/v1/routine_folders/{folderId}";
-var WithFolderItemRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: WithFolderItemRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutineFolderFromDiscriminatorValue
-  }
-};
-
-// src/generated/client/v1/routine_folders/index.ts
-function createRoutine_foldersGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine_foldersGetResponse;
-}
-function createRoutineFolder400ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutineFolder400Error;
-}
-function deserializeIntoRoutine_foldersGetResponse(routine_foldersGetResponse = {}) {
-  return {
-    "page": (n) => {
-      routine_foldersGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      routine_foldersGetResponse.pageCount = n.getNumberValue();
-    },
-    "routine_folders": (n) => {
-      routine_foldersGetResponse.routineFolders = n.getCollectionOfObjectValues(createRoutineFolderFromDiscriminatorValue);
-    }
-  };
-}
-function deserializeIntoRoutineFolder400Error(routineFolder400Error = {}) {
-  return {
-    "error": (n) => {
-      routineFolder400Error.errorEscaped = n.getStringValue();
-    }
-  };
-}
-var Routine_foldersRequestBuilderUriTemplate = "{+baseurl}/v1/routine_folders{?page*,pageSize*}";
-var Routine_foldersRequestBuilderNavigationMetadata = {
-  byFolderId: {
-    requestsMetadata: WithFolderItemRequestBuilderRequestsMetadata,
-    pathParametersMappings: ["folderId"]
-  }
-};
-var Routine_foldersRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutine_foldersGetResponseFromDiscriminatorValue
-  },
-  post: {
-    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    errorMappings: {
-      400: createRoutineFolder400ErrorFromDiscriminatorValue
-    },
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutineFolderFromDiscriminatorValue,
-    requestBodyContentType: "application/json",
-    requestBodySerializer: serializePostRoutineFolderRequestBody,
-    requestInformationContentSetMethod: "setContentFromParsable"
-  }
-};
-
-// src/generated/client/v1/routines/item/index.ts
-function createRoutine400ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine400Error;
-}
-function createRoutine404ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine404Error;
-}
-function deserializeIntoRoutine400Error(routine400Error = {}) {
-  return {
-    "error": (n) => {
-      routine400Error.errorEscaped = n.getStringValue();
-    }
-  };
-}
-function deserializeIntoRoutine404Error(routine404Error = {}) {
-  return {
-    "error": (n) => {
-      routine404Error.errorEscaped = n.getStringValue();
-    }
-  };
-}
-var WithRoutineItemRequestBuilderUriTemplate = "{+baseurl}/v1/routines/{routineId}";
-var WithRoutineItemRequestBuilderRequestsMetadata = {
-  put: {
-    uriTemplate: WithRoutineItemRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    errorMappings: {
-      400: createRoutine400ErrorFromDiscriminatorValue,
-      404: createRoutine404ErrorFromDiscriminatorValue
-    },
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutineFromDiscriminatorValue,
-    requestBodyContentType: "application/json",
-    requestBodySerializer: serializePutRoutinesRequestBody,
-    requestInformationContentSetMethod: "setContentFromParsable"
-  }
-};
-
-// src/generated/client/v1/routines/index.ts
-function createRoutine400ErrorFromDiscriminatorValue2(parseNode) {
-  return deserializeIntoRoutine400Error2;
-}
-function createRoutine403ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutine403Error;
-}
-function createRoutinesGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoRoutinesGetResponse;
-}
-function deserializeIntoRoutine400Error2(routine400Error = {}) {
-  return {
-    "error": (n) => {
-      routine400Error.errorEscaped = n.getStringValue();
-    }
-  };
-}
-function deserializeIntoRoutine403Error(routine403Error = {}) {
-  return {
-    "error": (n) => {
-      routine403Error.errorEscaped = n.getStringValue();
-    }
-  };
-}
-function deserializeIntoRoutinesGetResponse(routinesGetResponse = {}) {
-  return {
-    "page": (n) => {
-      routinesGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      routinesGetResponse.pageCount = n.getNumberValue();
-    },
-    "routines": (n) => {
-      routinesGetResponse.routines = n.getCollectionOfObjectValues(createRoutineFromDiscriminatorValue);
-    }
-  };
-}
-var RoutinesRequestBuilderUriTemplate = "{+baseurl}/v1/routines{?page*,pageSize*}";
-var RoutinesRequestBuilderNavigationMetadata = {
-  byRoutineId: {
-    requestsMetadata: WithRoutineItemRequestBuilderRequestsMetadata,
-    pathParametersMappings: ["routineId"]
-  }
-};
-var RoutinesRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: RoutinesRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutinesGetResponseFromDiscriminatorValue
-  },
-  post: {
-    uriTemplate: RoutinesRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    errorMappings: {
-      400: createRoutine400ErrorFromDiscriminatorValue2,
-      403: createRoutine403ErrorFromDiscriminatorValue
-    },
-    adapterMethodName: "send",
-    responseBodyFactory: createRoutineFromDiscriminatorValue,
-    requestBodyContentType: "application/json",
-    requestBodySerializer: serializePostRoutinesRequestBody,
-    requestInformationContentSetMethod: "setContentFromParsable"
-  }
-};
-
-// src/generated/client/v1/workouts/count/index.ts
-function createCountGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoCountGetResponse;
-}
-function deserializeIntoCountGetResponse(countGetResponse = {}) {
-  return {
-    "workout_count": (n) => {
-      countGetResponse.workoutCount = n.getNumberValue();
-    }
-  };
-}
-var CountRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/count";
-var CountRequestBuilderRequestsMetadata = {
-  get: {
-    uriTemplate: CountRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createCountGetResponseFromDiscriminatorValue
+    writer.writeNumberValue(
+      "custom_metric",
+      putRoutinesRequestSet.customMetric
+    );
+    writer.writeNumberValue(
+      "distance_meters",
+      putRoutinesRequestSet.distanceMeters
+    );
+    writer.writeNumberValue(
+      "duration_seconds",
+      putRoutinesRequestSet.durationSeconds
+    );
+    writer.writeNumberValue("reps", putRoutinesRequestSet.reps);
+    writer.writeEnumValue(
+      "type",
+      putRoutinesRequestSet.type
+    );
+    writer.writeNumberValue("weight_kg", putRoutinesRequestSet.weightKg);
+    writer.writeAdditionalData(putRoutinesRequestSet.additionalData);
   }
-};
+}
 
-// src/generated/client/v1/workouts/events/index.ts
-var EventsRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/events{?page*,pageSize*,since*}";
-var EventsRequestBuilderRequestsMetadata = {
+// src/generated/client/v1/exercise_templates/item/index.ts
+var WithExerciseTemplateItemRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates/{exerciseTemplateId}";
+var WithExerciseTemplateItemRequestBuilderRequestsMetadata = {
   get: {
-    uriTemplate: EventsRequestBuilderUriTemplate,
+    uriTemplate: WithExerciseTemplateItemRequestBuilderUriTemplate,
     responseBodyContentType: "application/json",
     adapterMethodName: "send",
-    responseBodyFactory: createPaginatedWorkoutEventsFromDiscriminatorValue
+    responseBodyFactory: createExerciseTemplateFromDiscriminatorValue
   }
 };
 
-// src/generated/client/v1/workouts/item/index.ts
-function createWorkout400ErrorFromDiscriminatorValue(parseNode) {
-  return deserializeIntoWorkout400Error;
+// src/generated/client/v1/exercise_templates/index.ts
+function createExercise_templatesGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoExercise_templatesGetResponse;
 }
-function deserializeIntoWorkout400Error(workout400Error = {}) {
+function deserializeIntoExercise_templatesGetResponse(exercise_templatesGetResponse = {}) {
   return {
-    "error": (n) => {
-      workout400Error.errorEscaped = n.getStringValue();
+    exercise_templates: (n) => {
+      exercise_templatesGetResponse.exerciseTemplates = n.getCollectionOfObjectValues(
+        createExerciseTemplateFromDiscriminatorValue
+      );
+    },
+    page: (n) => {
+      exercise_templatesGetResponse.page = n.getNumberValue();
+    },
+    page_count: (n) => {
+      exercise_templatesGetResponse.pageCount = n.getNumberValue();
     }
   };
 }
-var WithWorkoutItemRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/{workoutId}";
-var WithWorkoutItemRequestBuilderRequestsMetadata = {
+var Exercise_templatesRequestBuilderUriTemplate = "{+baseurl}/v1/exercise_templates{?page*,pageSize*}";
+var Exercise_templatesRequestBuilderNavigationMetadata = {
+  byExerciseTemplateId: {
+    requestsMetadata: WithExerciseTemplateItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["exerciseTemplateId"]
+  }
+};
+var Exercise_templatesRequestBuilderRequestsMetadata = {
   get: {
-    uriTemplate: WithWorkoutItemRequestBuilderUriTemplate,
+    uriTemplate: Exercise_templatesRequestBuilderUriTemplate,
     responseBodyContentType: "application/json",
     adapterMethodName: "send",
-    responseBodyFactory: createWorkoutFromDiscriminatorValue
-  },
-  put: {
-    uriTemplate: WithWorkoutItemRequestBuilderUriTemplate,
+    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",
-    errorMappings: {
-      400: createWorkout400ErrorFromDiscriminatorValue
-    },
     adapterMethodName: "send",
-    responseBodyFactory: createWorkoutFromDiscriminatorValue,
-    requestBodyContentType: "application/json",
-    requestBodySerializer: serializePostWorkoutsRequestBody,
-    requestInformationContentSetMethod: "setContentFromParsable"
+    responseBodyFactory: createRoutineFolderFromDiscriminatorValue
   }
 };
 
-// src/generated/client/v1/workouts/index.ts
-function createWorkout400ErrorFromDiscriminatorValue2(parseNode) {
-  return deserializeIntoWorkout400Error2;
+// src/generated/client/v1/routine_folders/index.ts
+function createRoutine_foldersGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine_foldersGetResponse;
 }
-function createWorkoutsGetResponseFromDiscriminatorValue(parseNode) {
-  return deserializeIntoWorkoutsGetResponse;
+function createRoutineFolder400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutineFolder400Error;
 }
-function deserializeIntoWorkout400Error2(workout400Error = {}) {
+function deserializeIntoRoutine_foldersGetResponse(routine_foldersGetResponse = {}) {
   return {
-    "error": (n) => {
-      workout400Error.errorEscaped = n.getStringValue();
+    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 deserializeIntoWorkoutsGetResponse(workoutsGetResponse = {}) {
+function deserializeIntoRoutineFolder400Error(routineFolder400Error = {}) {
   return {
-    "page": (n) => {
-      workoutsGetResponse.page = n.getNumberValue();
-    },
-    "page_count": (n) => {
-      workoutsGetResponse.pageCount = n.getNumberValue();
-    },
-    "workouts": (n) => {
-      workoutsGetResponse.workouts = n.getCollectionOfObjectValues(createWorkoutFromDiscriminatorValue);
+    error: (n) => {
+      routineFolder400Error.errorEscaped = n.getStringValue();
     }
   };
 }
-var WorkoutsRequestBuilderUriTemplate = "{+baseurl}/v1/workouts{?page*,pageSize*}";
-var WorkoutsRequestBuilderNavigationMetadata = {
-  byWorkoutId: {
-    requestsMetadata: WithWorkoutItemRequestBuilderRequestsMetadata,
-    pathParametersMappings: ["workoutId"]
-  },
-  count: {
-    requestsMetadata: CountRequestBuilderRequestsMetadata
-  },
-  events: {
-    requestsMetadata: EventsRequestBuilderRequestsMetadata
+var Routine_foldersRequestBuilderUriTemplate = "{+baseurl}/v1/routine_folders{?page*,pageSize*}";
+var Routine_foldersRequestBuilderNavigationMetadata = {
+  byFolderId: {
+    requestsMetadata: WithFolderItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["folderId"]
   }
 };
-var WorkoutsRequestBuilderRequestsMetadata = {
+var Routine_foldersRequestBuilderRequestsMetadata = {
   get: {
-    uriTemplate: WorkoutsRequestBuilderUriTemplate,
-    responseBodyContentType: "application/json",
-    adapterMethodName: "send",
-    responseBodyFactory: createWorkoutsGetResponseFromDiscriminatorValue
-  },
-  post: {
-    uriTemplate: WorkoutsRequestBuilderUriTemplate,
+    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
     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
+    responseBodyFactory: createRoutine_foldersGetResponseFromDiscriminatorValue
   },
-  workouts: {
-    requestsMetadata: WorkoutsRequestBuilderRequestsMetadata,
-    navigationMetadata: WorkoutsRequestBuilderNavigationMetadata
-  }
-};
-
-// src/generated/client/hevyClient.ts
-import { apiClientProxifier, registerDefaultDeserializer, registerDefaultSerializer } from "@microsoft/kiota-abstractions";
-
-// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formParseNode.js
-import { createBackedModelProxyHandler, DateOnly, Duration, parseGuidString, TimeOnly, isBackingStoreEnabled, getEnumValueFromStringValue } from "@microsoft/kiota-abstractions";
-var FormParseNode = class _FormParseNode {
-  /**
-   *  Creates a new instance of FormParseNode
-   * @param _rawString the raw string to parse
-   * @param backingStoreFactory the factory to create backing stores
-   */
-  constructor(_rawString, backingStoreFactory) {
-    this._rawString = _rawString;
-    this.backingStoreFactory = backingStoreFactory;
-    this._fields = {};
-    this.normalizeKey = (key) => decodeURIComponent(key).trim();
-    this.getStringValue = () => decodeURIComponent(this._rawString);
-    this.getChildNode = (identifier) => {
-      if (this._fields[identifier]) {
-        return new _FormParseNode(this._fields[identifier], this.backingStoreFactory);
-      }
-      return void 0;
-    };
-    this.getBooleanValue = () => {
-      var _a;
-      const value = (_a = this.getStringValue()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-      if (value === "true" || value === "1") {
-        return true;
-      } else if (value === "false" || value === "0") {
-        return false;
-      }
-      return void 0;
-    };
-    this.getNumberValue = () => parseFloat(this.getStringValue());
-    this.getGuidValue = () => parseGuidString(this.getStringValue());
-    this.getDateValue = () => new Date(Date.parse(this.getStringValue()));
-    this.getDateOnlyValue = () => DateOnly.parse(this.getStringValue());
-    this.getTimeOnlyValue = () => TimeOnly.parse(this.getStringValue());
-    this.getDurationValue = () => Duration.parse(this.getStringValue());
-    this.getCollectionOfPrimitiveValues = () => {
-      return this._rawString.split(",").map((x) => {
-        const currentParseNode = new _FormParseNode(x, this.backingStoreFactory);
-        const typeOfX = typeof x;
-        if (typeOfX === "boolean") {
-          return currentParseNode.getBooleanValue();
-        } else if (typeOfX === "string") {
-          return currentParseNode.getStringValue();
-        } else if (typeOfX === "number") {
-          return currentParseNode.getNumberValue();
-        } else if (x instanceof Date) {
-          return currentParseNode.getDateValue();
-        } else if (x instanceof DateOnly) {
-          return currentParseNode.getDateValue();
-        } else if (x instanceof TimeOnly) {
-          return currentParseNode.getDateValue();
-        } else if (x instanceof Duration) {
-          return currentParseNode.getDateValue();
-        } else {
-          throw new Error(`encountered an unknown type during deserialization ${typeof x}`);
-        }
-      });
-    };
-    this.getCollectionOfObjectValues = (parsableFactory) => {
-      throw new Error(`serialization of collections is not supported with URI encoding`);
-    };
-    this.getObjectValue = (parsableFactory) => {
-      const temp = {};
-      const enableBackingStore = isBackingStoreEnabled(parsableFactory(this)(temp));
-      const value = enableBackingStore && this.backingStoreFactory ? new Proxy(temp, createBackedModelProxyHandler(this.backingStoreFactory)) : temp;
-      if (this.onBeforeAssignFieldValues) {
-        this.onBeforeAssignFieldValues(value);
-      }
-      this.assignFieldValues(value, parsableFactory);
-      if (this.onAfterAssignFieldValues) {
-        this.onAfterAssignFieldValues(value);
-      }
-      return value;
-    };
-    this.getCollectionOfEnumValues = (type) => {
-      const rawValues = this.getStringValue();
-      if (!rawValues) {
-        return [];
-      }
-      return rawValues.split(",").map((x) => getEnumValueFromStringValue(x, type));
-    };
-    this.getEnumValue = (type) => {
-      const rawValue = this.getStringValue();
-      if (!rawValue) {
-        return void 0;
-      }
-      return getEnumValueFromStringValue(rawValue, type);
-    };
-    this.assignFieldValues = (model, parsableFactory) => {
-      const fields = parsableFactory(this)(model);
-      Object.entries(this._fields).filter((x) => !/^null$/i.test(x[1])).forEach(([k, v]) => {
-        const deserializer = fields[k];
-        if (deserializer) {
-          deserializer(new _FormParseNode(v, this.backingStoreFactory));
-        } else {
-          model[k] = v;
-        }
-      });
-    };
-    if (!_rawString) {
-      throw new Error("rawString cannot be undefined");
-    }
-    _rawString.split("&").map((x) => x.split("=")).filter((x) => x.length === 2).forEach((x) => {
-      const key = this.normalizeKey(x[0]);
-      if (this._fields[key]) {
-        this._fields[key] += "," + x[1];
-      } else {
-        this._fields[key] = x[1];
-      }
-    });
-  }
-  getByteArrayValue() {
-    throw new Error("serialization of byt arrays is not supported with URI encoding");
+  post: {
+    uriTemplate: Routine_foldersRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createRoutineFolder400ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFolderFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePostRoutineFolderRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
   }
 };
 
-// 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");
+// src/generated/client/v1/routines/item/index.ts
+function createRoutine400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine400Error;
+}
+function createRoutine404ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine404Error;
+}
+function deserializeIntoRoutine400Error(routine400Error = {}) {
+  return {
+    error: (n) => {
+      routine400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine404Error(routine404Error = {}) {
+  return {
+    error: (n) => {
+      routine404Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+var WithRoutineItemRequestBuilderUriTemplate = "{+baseurl}/v1/routines/{routineId}";
+var WithRoutineItemRequestBuilderRequestsMetadata = {
+  put: {
+    uriTemplate: WithRoutineItemRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    errorMappings: {
+      400: createRoutine400ErrorFromDiscriminatorValue,
+      404: createRoutine404ErrorFromDiscriminatorValue
+    },
+    adapterMethodName: "send",
+    responseBodyFactory: createRoutineFromDiscriminatorValue,
+    requestBodyContentType: "application/json",
+    requestBodySerializer: serializePutRoutinesRequestBody,
+    requestInformationContentSetMethod: "setContentFromParsable"
   }
 };
-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;
+// src/generated/client/v1/routines/index.ts
+function createRoutine400ErrorFromDiscriminatorValue2(parseNode) {
+  return deserializeIntoRoutine400Error2;
+}
+function createRoutine403ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutine403Error;
+}
+function createRoutinesGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoRoutinesGetResponse;
+}
+function deserializeIntoRoutine400Error2(routine400Error = {}) {
+  return {
+    error: (n) => {
+      routine400Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutine403Error(routine403Error = {}) {
+  return {
+    error: (n) => {
+      routine403Error.errorEscaped = n.getStringValue();
+    }
+  };
+}
+function deserializeIntoRoutinesGetResponse(routinesGetResponse = {}) {
+  return {
+    page: (n) => {
+      routinesGetResponse.page = n.getNumberValue();
+    },
+    page_count: (n) => {
+      routinesGetResponse.pageCount = n.getNumberValue();
+    },
+    routines: (n) => {
+      routinesGetResponse.routines = n.getCollectionOfObjectValues(
+        createRoutineFromDiscriminatorValue
+      );
+    }
+  };
+}
+var RoutinesRequestBuilderUriTemplate = "{+baseurl}/v1/routines{?page*,pageSize*}";
+var RoutinesRequestBuilderNavigationMetadata = {
+  byRoutineId: {
+    requestsMetadata: WithRoutineItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["routineId"]
   }
-  getValidContentType() {
-    return "application/x-www-form-urlencoded";
+};
+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"
   }
-  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`);
+};
+
+// src/generated/client/v1/workouts/count/index.ts
+function createCountGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoCountGetResponse;
+}
+function deserializeIntoCountGetResponse(countGetResponse = {}) {
+  return {
+    workout_count: (n) => {
+      countGetResponse.workoutCount = n.getNumberValue();
     }
-    return new FormParseNode(this.convertArrayBufferToString(content), this.backingStoreFactory);
-  }
-  convertArrayBufferToString(content) {
-    const decoder = new TextDecoder();
-    return decoder.decode(content);
+  };
+}
+var CountRequestBuilderUriTemplate = "{+baseurl}/v1/workouts/count";
+var CountRequestBuilderRequestsMetadata = {
+  get: {
+    uriTemplate: CountRequestBuilderUriTemplate,
+    responseBodyContentType: "application/json",
+    adapterMethodName: "send",
+    responseBodyFactory: createCountGetResponseFromDiscriminatorValue
   }
 };
 
-// node_modules/@microsoft/kiota-serialization-form/dist/es/src/formSerializationWriterFactory.js
-var FormSerializationWriterFactory = class {
-  getValidContentType() {
-    return "application/x-www-form-urlencoded";
+// 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
   }
-  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`);
+};
+
+// src/generated/client/v1/workouts/item/index.ts
+function createWorkout400ErrorFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkout400Error;
+}
+function deserializeIntoWorkout400Error(workout400Error = {}) {
+  return {
+    error: (n) => {
+      workout400Error.errorEscaped = n.getStringValue();
     }
-    return new FormSerializationWriter();
+  };
+}
+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/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");
+// src/generated/client/v1/workouts/index.ts
+function createWorkout400ErrorFromDiscriminatorValue2(parseNode) {
+  return deserializeIntoWorkout400Error2;
+}
+function createWorkoutsGetResponseFromDiscriminatorValue(parseNode) {
+  return deserializeIntoWorkoutsGetResponse;
+}
+function deserializeIntoWorkout400Error2(workout400Error = {}) {
+  return {
+    error: (n) => {
+      workout400Error.errorEscaped = n.getStringValue();
     }
-    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);
+  };
+}
+function deserializeIntoWorkoutsGetResponse(workoutsGetResponse = {}) {
+  return {
+    page: (n) => {
+      workoutsGetResponse.page = n.getNumberValue();
+    },
+    page_count: (n) => {
+      workoutsGetResponse.pageCount = n.getNumberValue();
+    },
+    workouts: (n) => {
+      workoutsGetResponse.workouts = n.getCollectionOfObjectValues(
+        createWorkoutFromDiscriminatorValue
+      );
+    }
+  };
+}
+var WorkoutsRequestBuilderUriTemplate = "{+baseurl}/v1/workouts{?page*,pageSize*}";
+var WorkoutsRequestBuilderNavigationMetadata = {
+  byWorkoutId: {
+    requestsMetadata: WithWorkoutItemRequestBuilderRequestsMetadata,
+    pathParametersMappings: ["workoutId"]
+  },
+  count: {
+    requestsMetadata: CountRequestBuilderRequestsMetadata
+  },
+  events: {
+    requestsMetadata: EventsRequestBuilderRequestsMetadata
   }
 };
-
-// node_modules/@microsoft/kiota-serialization-multipart/dist/es/src/multipartSerializationWriterFactory.js
-var MultipartSerializationWriterFactory = class {
-  getValidContentType() {
-    return "multipart/form-data";
+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"
   }
-  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/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 { TextParseNodeFactory, TextSerializationWriterFactory } from "@microsoft/kiota-serialization-text";
 function createHevyClient(requestAdapter) {
   registerDefaultSerializer(JsonSerializationWriterFactory);
   registerDefaultSerializer(TextSerializationWriterFactory);
@@ -2053,9 +2211,14 @@ function createHevyClient(requestAdapter) {
   registerDefaultDeserializer(TextParseNodeFactory);
   registerDefaultDeserializer(FormParseNodeFactory);
   const pathParameters = {
-    "baseurl": requestAdapter.baseUrl
+    baseurl: requestAdapter.baseUrl
   };
-  return apiClientProxifier(requestAdapter, pathParameters, HevyClientNavigationMetadata, void 0);
+  return apiClientProxifier(
+    requestAdapter,
+    pathParameters,
+    HevyClientNavigationMetadata,
+    void 0
+  );
 }
 var HevyClientNavigationMetadata = {
   v1: {
@@ -2064,27 +2227,18 @@ var HevyClientNavigationMetadata = {
 };
 
 // src/utils/hevyClient.ts
-var ApiKeyAuthProvider = class {
-  apiKey;
-  constructor(apiKey2) {
-    this.apiKey = apiKey2;
-  }
-  async authenticateRequest(request) {
-    request.headers.add("x-api-key", this.apiKey);
-  }
-};
 function createClient(apiKey2, baseUrl) {
-  const authProvider = new ApiKeyAuthProvider(apiKey2);
+  const authProvider = new ApiKeyAuthenticationProvider(apiKey2, "api-key", ApiKeyLocation.Header);
   const adapter = new FetchRequestAdapter(authProvider);
   adapter.baseUrl = baseUrl;
   return createHevyClient(adapter);
 }
 
 // src/index.ts
-var HEVY_API_BASEURL = "https://api.hevyapp.com/";
+var HEVY_API_BASEURL = "https://api.hevyapp.com";
 var server = new McpServer({
   name: "hevy",
-  version: "1.0.0"
+  version: "1.0.1"
 });
 if (!process.env.API_KEY) {
   console.error("API_KEY environment variable is not set");