@strong-together/shared 1.0.5

package/dist/index.js

@@ -0,0 +1,666 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  addAerobicsRequest: () => addAerobicsRequest,
+  addWorkoutRequest: () => addWorkoutRequest,
+  addWorkoutResponseSchema: () => addWorkoutResponseSchema,
+  adherenceExerciseStatsSchema: () => adherenceExerciseStatsSchema,
+  aerobicsDailyRecordSchema: () => aerobicsDailyRecordSchema,
+  aerobicsWeeklyRecordSchema: () => aerobicsWeeklyRecordSchema,
+  allUserMessageSchema: () => allUserMessageSchema,
+  appleOAuthRequest: () => appleOAuthRequest,
+  bootstrapRequest: () => bootstrapRequest,
+  bootstrapResponseSchema: () => bootstrapResponseSchema,
+  changeEmailAndVerifyRequest: () => changeEmailAndVerifyRequest,
+  checkUserVerifyRequest: () => checkUserVerifyRequest,
+  createUserRequest: () => createUserRequest,
+  createUserResponseSchema: () => createUserResponseSchema,
+  createUserUserSchema: () => createUserUserSchema,
+  deleteMessageRequest: () => deleteMessageRequest,
+  deleteMessageResponseSchema: () => deleteMessageResponseSchema,
+  deleteProfilePicRequest: () => deleteProfilePicRequest,
+  deletedMessageSchema: () => deletedMessageSchema,
+  exerciseInPlanSchema: () => exerciseInPlanSchema,
+  exerciseMetadataSchema: () => exerciseMetadataSchema,
+  exerciseTrackingAnalysisSchema: () => exerciseTrackingAnalysisSchema,
+  exerciseTrackingAndStatsSchema: () => exerciseTrackingAndStatsSchema,
+  exerciseTrackingPrMaxSchema: () => exerciseTrackingPrMaxSchema,
+  finishUserWorkoutResponseSchema: () => finishUserWorkoutResponseSchema,
+  finishWorkoutRequest: () => finishWorkoutRequest,
+  generateTicketRequest: () => generateTicketRequest,
+  generateTicketResponseSchema: () => generateTicketResponseSchema,
+  getAerobicsRequest: () => getAerobicsRequest,
+  getAllExercisesResponseSchema: () => getAllExercisesResponseSchema,
+  getAllMessagesRequest: () => getAllMessagesRequest,
+  getAllUserMessagesResponseSchema: () => getAllUserMessagesResponseSchema,
+  getAnalyticsResponseSchema: () => getAnalyticsResponseSchema,
+  getAuthenticatedUserByIdResponseSchema: () => getAuthenticatedUserByIdResponseSchema,
+  getExerciseTrackingRequest: () => getExerciseTrackingRequest,
+  getExerciseTrackingResponseSchema: () => getExerciseTrackingResponseSchema,
+  getPresignedUrlFromS3ResponseSchema: () => getPresignedUrlFromS3ResponseSchema,
+  getPresignedUrlS3Request: () => getPresignedUrlS3Request,
+  getWholeUserWorkoutPlanResponseSchema: () => getWholeUserWorkoutPlanResponseSchema,
+  getWholeWorkoutPlanRequest: () => getWholeWorkoutPlanRequest,
+  googleOAuthRequest: () => googleOAuthRequest,
+  loginRequest: () => loginRequest,
+  loginResponseSchema: () => loginResponseSchema,
+  logoutResponseSchema: () => logoutResponseSchema,
+  markMessageAsReadRequest: () => markMessageAsReadRequest,
+  markMessageAsReadResponseSchema: () => markMessageAsReadResponseSchema,
+  messageAsReadSchema: () => messageAsReadSchema,
+  oAuthLoginResponseSchema: () => oAuthLoginResponseSchema,
+  proceedLoginResponseSchema: () => proceedLoginResponseSchema,
+  refreshTokenResponseSchema: () => refreshTokenResponseSchema,
+  resetPasswordRequest: () => resetPasswordRequest,
+  resetPasswordResponseSchema: () => resetPasswordResponseSchema,
+  saveUserPushTokenRequest: () => saveUserPushTokenRequest,
+  sendChangePassEmailRequest: () => sendChangePassEmailRequest,
+  sendVerificationMailRequest: () => sendVerificationMailRequest,
+  setProfilePicAndUpdateDBResponseSchema: () => setProfilePicAndUpdateDBResponseSchema,
+  trackingByDateItemSchema: () => trackingByDateItemSchema,
+  trackingBySplitNameItemSchema: () => trackingBySplitNameItemSchema,
+  trackingMapItemSchema: () => trackingMapItemSchema,
+  updateAuthenticatedUserResponseSchema: () => updateAuthenticatedUserResponseSchema,
+  updateUserRequest: () => updateUserRequest,
+  userAerobicsResponseSchema: () => userAerobicsResponseSchema,
+  userDataResponseSchema: () => userDataResponseSchema,
+  userDataSchema: () => userDataSchema,
+  verifyAccountRequest: () => verifyAccountRequest,
+  weeklyDataSchema: () => weeklyDataSchema,
+  wholeUserWorkoutPlanSchema: () => wholeUserWorkoutPlanSchema,
+  workoutRmRecordSchema: () => workoutRmRecordSchema,
+  workoutSplitSchema: () => workoutSplitSchema,
+  workoutSplitsMapItemSchema: () => workoutSplitsMapItemSchema,
+  workoutSplitsMapSchema: () => workoutSplitsMapSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/modules/aerobics/aerobics.schemas.ts
+var import_zod = __toESM(require("zod"));
+var addAerobicInput = import_zod.default.object({
+  durationMins: import_zod.default.number(),
+  durationSec: import_zod.default.number(),
+  type: import_zod.default.string()
+});
+var addAerobicsRequest = import_zod.default.object({
+  body: import_zod.default.object({
+    tz: import_zod.default.string(),
+    record: addAerobicInput
+  })
+});
+var getAerobicsRequest = import_zod.default.object({
+  query: import_zod.default.object({
+    tz: import_zod.default.string().optional()
+  })
+});
+var aerobicsDailyRecordSchema = import_zod.default.object({
+  type: import_zod.default.string(),
+  duration_sec: import_zod.default.number(),
+  duration_mins: import_zod.default.number()
+});
+var aerobicsWeeklyRecordSchema = aerobicsDailyRecordSchema.extend({
+  workout_time_utc: import_zod.default.string()
+});
+var weeklyDataSchema = import_zod.default.object({
+  records: import_zod.default.array(aerobicsWeeklyRecordSchema),
+  total_duration_sec: import_zod.default.number(),
+  total_duration_mins: import_zod.default.number()
+});
+var userAerobicsResponseSchema = import_zod.default.object({
+  daily: import_zod.default.record(import_zod.default.string(), import_zod.default.array(aerobicsDailyRecordSchema)),
+  weekly: import_zod.default.record(import_zod.default.string(), weeklyDataSchema)
+});
+
+// src/modules/analytics/analytics.schemas.ts
+var import_zod2 = require("zod");
+var workoutRmRecordSchema = import_zod2.z.object({
+  exercise: import_zod2.z.string(),
+  pr_weight: import_zod2.z.number().nullable(),
+  pr_reps: import_zod2.z.number().nullable(),
+  max_1rm: import_zod2.z.number()
+});
+var adherenceExerciseStatsSchema = import_zod2.z.object({
+  planned: import_zod2.z.number(),
+  actual: import_zod2.z.number(),
+  adherence_pct: import_zod2.z.number().nullable()
+});
+var getAnalyticsResponseSchema = import_zod2.z.object({
+  _1RM: import_zod2.z.record(import_zod2.z.string(), workoutRmRecordSchema),
+  goals: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.record(import_zod2.z.string(), adherenceExerciseStatsSchema))
+});
+
+// src/modules/auth/password/password.schemas.ts
+var import_zod3 = require("zod");
+var sendChangePassEmailRequest = import_zod3.z.object({
+  body: import_zod3.z.object({ identifier: import_zod3.z.string() })
+});
+var resetPasswordRequest = import_zod3.z.object({
+  body: import_zod3.z.object({
+    newPassword: import_zod3.z.string().min(8, "Password must be at least 8 characters long")
+  }),
+  query: import_zod3.z.object({
+    token: import_zod3.z.string().optional()
+  })
+});
+var resetPasswordResponseSchema = import_zod3.z.object({
+  ok: import_zod3.z.boolean()
+});
+
+// src/modules/auth/session/session.schemas.ts
+var import_zod4 = require("zod");
+var loginRequest = import_zod4.z.object({
+  body: import_zod4.z.object({
+    identifier: import_zod4.z.string().min(3).refine(
+      (val) => {
+        const isEmail = import_zod4.z.string().email().safeParse(val).success;
+        const isUsername = /^[a-zA-Z0-9_]{3,20}$/.test(val);
+        return isEmail || isUsername;
+      },
+      {
+        message: "Must be a valid email or username"
+      }
+    ),
+    password: import_zod4.z.string().min(1, "Username and password are required")
+  })
+});
+var loginResponseSchema = import_zod4.z.object({
+  message: import_zod4.z.string(),
+  user: import_zod4.z.string(),
+  accessToken: import_zod4.z.string(),
+  refreshToken: import_zod4.z.string()
+});
+var logoutResponseSchema = import_zod4.z.object({
+  message: import_zod4.z.string()
+});
+var refreshTokenResponseSchema = import_zod4.z.object({
+  message: import_zod4.z.string(),
+  accessToken: import_zod4.z.string(),
+  refreshToken: import_zod4.z.string(),
+  userId: import_zod4.z.string()
+});
+
+// src/modules/auth/verification/verification.schemas.ts
+var import_zod5 = __toESM(require("zod"));
+var verifyAccountRequest = import_zod5.default.object({
+  query: import_zod5.default.object({
+    token: import_zod5.default.string().optional()
+  })
+});
+var sendVerificationMailRequest = import_zod5.default.object({
+  body: import_zod5.default.object({ email: import_zod5.default.string().trim().email("Invalid email") })
+});
+var changeEmailAndVerifyRequest = import_zod5.default.object({
+  body: import_zod5.default.object({ username: import_zod5.default.string(), password: import_zod5.default.string(), newEmail: import_zod5.default.string().trim().email("Invalid email") })
+});
+var checkUserVerifyRequest = import_zod5.default.object({
+  query: import_zod5.default.object({ username: import_zod5.default.string() })
+});
+
+// src/modules/bootstrap/bootstrap.schemas.ts
+var import_zod10 = require("zod");
+
+// src/modules/messages/messages.schemas.ts
+var import_zod6 = require("zod");
+var getAllMessagesRequest = import_zod6.z.object({
+  query: import_zod6.z.object({
+    tz: import_zod6.z.string()
+  })
+});
+var allUserMessageSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  subject: import_zod6.z.string(),
+  msg: import_zod6.z.string(),
+  sent_at: import_zod6.z.string(),
+  is_read: import_zod6.z.boolean(),
+  sender_full_name: import_zod6.z.string(),
+  sender_profile_image_url: import_zod6.z.string().nullable()
+});
+var getAllUserMessagesResponseSchema = import_zod6.z.object({
+  messages: import_zod6.z.array(allUserMessageSchema)
+});
+var markMessageAsReadRequest = import_zod6.z.object({
+  params: import_zod6.z.object({
+    id: import_zod6.z.string()
+    // MSG ID
+  })
+});
+var messageAsReadSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  is_read: import_zod6.z.boolean()
+});
+var markMessageAsReadResponseSchema = messageAsReadSchema;
+var deleteMessageRequest = import_zod6.z.object({
+  params: import_zod6.z.object({
+    id: import_zod6.z.string()
+    // MSG ID
+  })
+});
+var deletedMessageSchema = import_zod6.z.object({
+  id: import_zod6.z.string()
+});
+var deleteMessageResponseSchema = deletedMessageSchema;
+
+// src/modules/user/update/update.schemas.ts
+var import_zod7 = require("zod");
+var updateUserRequest = import_zod7.z.object({
+  body: import_zod7.z.object({
+    username: import_zod7.z.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
+    fullName: import_zod7.z.string().trim().min(1, "Full name is required").max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only"),
+    email: import_zod7.z.string().trim().toLowerCase().email("Invalid email format")
+  }).partial()
+});
+var deleteProfilePicRequest = import_zod7.z.object({
+  body: import_zod7.z.object({
+    path: import_zod7.z.string()
+  })
+});
+var userDataSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  username: import_zod7.z.string(),
+  email: import_zod7.z.string().nullable(),
+  name: import_zod7.z.string(),
+  gender: import_zod7.z.string(),
+  created_at: import_zod7.z.string(),
+  profile_image_url: import_zod7.z.string().nullable(),
+  push_token: import_zod7.z.string().nullable(),
+  role: import_zod7.z.string(),
+  is_first_login: import_zod7.z.boolean(),
+  token_version: import_zod7.z.number(),
+  is_verified: import_zod7.z.boolean(),
+  auth_provider: import_zod7.z.string()
+});
+var userDataResponseSchema = import_zod7.z.object({
+  user_data: userDataSchema
+});
+var getAuthenticatedUserByIdResponseSchema = userDataSchema;
+var updateAuthenticatedUserResponseSchema = import_zod7.z.object({
+  message: import_zod7.z.string(),
+  emailChanged: import_zod7.z.boolean(),
+  user: userDataSchema
+});
+var setProfilePicAndUpdateDBResponseSchema = import_zod7.z.object({
+  path: import_zod7.z.string(),
+  url: import_zod7.z.string(),
+  message: import_zod7.z.string()
+});
+
+// src/modules/workout/plan/plan.schemas.ts
+var import_zod8 = require("zod");
+var workoutExerciseSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  sets: import_zod8.z.array(import_zod8.z.number()),
+  order_index: import_zod8.z.number()
+});
+var exerciseInPlanSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  sets: import_zod8.z.array(import_zod8.z.number()),
+  is_active: import_zod8.z.boolean(),
+  targetmuscle: import_zod8.z.string(),
+  specifictargetmuscle: import_zod8.z.string(),
+  exercise: import_zod8.z.string(),
+  workoutsplit: import_zod8.z.string()
+});
+var workoutSplitSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  workout_id: import_zod8.z.number(),
+  name: import_zod8.z.string(),
+  created_at: import_zod8.z.string(),
+  muscle_group: import_zod8.z.string().nullable(),
+  is_active: import_zod8.z.boolean(),
+  exercisetoworkoutsplit: import_zod8.z.array(exerciseInPlanSchema)
+});
+var wholeUserWorkoutPlanSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  name: import_zod8.z.string(),
+  numberofsplits: import_zod8.z.number(),
+  created_at: import_zod8.z.string(),
+  is_deleted: import_zod8.z.boolean(),
+  level: import_zod8.z.string(),
+  user_id: import_zod8.z.string(),
+  trainer_id: import_zod8.z.string(),
+  is_active: import_zod8.z.boolean(),
+  updated_at: import_zod8.z.string(),
+  workoutsplits: import_zod8.z.array(workoutSplitSchema).nullable()
+});
+var workoutSplitsMapItemSchema = import_zod8.z.object({
+  id: import_zod8.z.number(),
+  name: import_zod8.z.string(),
+  sets: import_zod8.z.array(import_zod8.z.number()),
+  order_index: import_zod8.z.number(),
+  targetmuscle: import_zod8.z.string(),
+  specifictargetmuscle: import_zod8.z.string()
+});
+var workoutSplitsMapSchema = import_zod8.z.record(import_zod8.z.string(), import_zod8.z.array(workoutSplitsMapItemSchema));
+var addWorkoutSplitPayloadSchema = import_zod8.z.record(
+  import_zod8.z.string(),
+  import_zod8.z.array(workoutExerciseSchema).min(1, "Each split must include at least one exercise")
+);
+var addWorkoutRequest = import_zod8.z.object({
+  body: import_zod8.z.object({
+    workoutData: addWorkoutSplitPayloadSchema,
+    workoutName: import_zod8.z.string().optional(),
+    tz: import_zod8.z.string()
+  })
+});
+var addWorkoutResponseSchema = import_zod8.z.object({
+  message: import_zod8.z.string(),
+  workoutPlan: wholeUserWorkoutPlanSchema,
+  workoutPlanForEditWorkout: workoutSplitsMapSchema
+});
+var getWholeWorkoutPlanRequest = import_zod8.z.object({
+  query: import_zod8.z.object({
+    tz: import_zod8.z.string().optional()
+  })
+});
+var getWholeUserWorkoutPlanResponseSchema = import_zod8.z.object({
+  workoutPlan: wholeUserWorkoutPlanSchema.nullable(),
+  workoutPlanForEditWorkout: workoutSplitsMapSchema.nullable()
+});
+
+// src/modules/workout/tracking/tracking.schemas.ts
+var import_zod9 = require("zod");
+var finishedExerciseEntry = import_zod9.z.object({
+  exercisetosplit_id: import_zod9.z.number(),
+  weight: import_zod9.z.array(import_zod9.z.number()),
+  reps: import_zod9.z.array(import_zod9.z.number()),
+  notes: import_zod9.z.string().optional().nullable()
+});
+var exerciseMetadataSchema = import_zod9.z.object({
+  targetmuscle: import_zod9.z.string(),
+  specifictargetmuscle: import_zod9.z.string()
+});
+var exerciseTrackingPrMaxSchema = import_zod9.z.object({
+  exercise: import_zod9.z.string(),
+  weight: import_zod9.z.number(),
+  reps: import_zod9.z.number(),
+  workout_time_utc: import_zod9.z.string()
+});
+var exerciseTrackingAnalysisSchema = import_zod9.z.object({
+  unique_days: import_zod9.z.number(),
+  most_frequent_split: import_zod9.z.string().nullable(),
+  most_frequent_split_days: import_zod9.z.number().nullable(),
+  lastWorkoutDate: import_zod9.z.string().nullable(),
+  splitDaysByName: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.number()),
+  prs: import_zod9.z.object({
+    pr_max: exerciseTrackingPrMaxSchema.nullable()
+  })
+});
+var trackingMapItemSchema = import_zod9.z.object({
+  id: import_zod9.z.number(),
+  exercisetosplit_id: import_zod9.z.number(),
+  weight: import_zod9.z.array(import_zod9.z.number()),
+  reps: import_zod9.z.array(import_zod9.z.number()),
+  notes: import_zod9.z.string().nullable(),
+  exercise_id: import_zod9.z.number(),
+  workoutsplit_id: import_zod9.z.number(),
+  splitname: import_zod9.z.string(),
+  exercise: import_zod9.z.string(),
+  workoutdate: import_zod9.z.string(),
+  order_index: import_zod9.z.number(),
+  exercisetoworkoutsplit: import_zod9.z.object({
+    sets: import_zod9.z.array(import_zod9.z.number()),
+    exercises: exerciseMetadataSchema
+  })
+});
+var trackingByDateItemSchema = trackingMapItemSchema.omit({ workoutdate: true });
+var trackingBySplitNameItemSchema = trackingMapItemSchema.omit({ splitname: true });
+var exerciseTrackingAndStatsSchema = import_zod9.z.object({
+  exerciseTrackingAnalysis: exerciseTrackingAnalysisSchema,
+  exerciseTrackingMaps: import_zod9.z.object({
+    byDate: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingByDateItemSchema)),
+    byETSId: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingMapItemSchema)),
+    bySplitName: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(trackingBySplitNameItemSchema))
+  })
+});
+var finishWorkoutRequest = import_zod9.z.object({
+  body: import_zod9.z.object({
+    workout: import_zod9.z.array(finishedExerciseEntry),
+    tz: import_zod9.z.string().optional(),
+    workout_start_utc: import_zod9.z.string().datetime("workout_start_utc must be a valid ISO datetime"),
+    workout_end_utc: import_zod9.z.string().datetime("workout_end_utc must be a valid ISO datetime").optional().nullable()
+  })
+});
+var finishUserWorkoutResponseSchema = exerciseTrackingAndStatsSchema;
+var getExerciseTrackingRequest = import_zod9.z.object({
+  query: import_zod9.z.object({
+    tz: import_zod9.z.string().optional()
+  })
+});
+var getExerciseTrackingResponseSchema = exerciseTrackingAndStatsSchema;
+
+// src/modules/bootstrap/bootstrap.schemas.ts
+var bootstrapRequest = import_zod10.z.object({
+  query: import_zod10.z.object({
+    tz: import_zod10.z.string().optional()
+  })
+});
+var bootstrapResponseSchema = import_zod10.z.object({
+  user: userDataSchema,
+  workout: getWholeUserWorkoutPlanResponseSchema,
+  tracking: exerciseTrackingAndStatsSchema,
+  messages: getAllUserMessagesResponseSchema,
+  aerobics: userAerobicsResponseSchema
+});
+
+// src/modules/exercises/exercises.schemas.ts
+var import_zod11 = require("zod");
+var getAllExercisesResponseSchema = import_zod11.z.record(
+  import_zod11.z.string(),
+  import_zod11.z.array(
+    import_zod11.z.object({
+      id: import_zod11.z.number(),
+      name: import_zod11.z.string(),
+      specificTargetMuscle: import_zod11.z.string()
+    })
+  )
+);
+
+// src/modules/oauth/apple/apple.schemas.ts
+var import_zod12 = require("zod");
+var appleNameInput = import_zod12.z.object({
+  givenName: import_zod12.z.string().nullable(),
+  familyName: import_zod12.z.string().nullable()
+});
+var appleOAuthRequest = import_zod12.z.object({
+  body: import_zod12.z.object({
+    idToken: import_zod12.z.string({
+      required_error: "Missing or invalid Apple identityToken",
+      invalid_type_error: "Missing or invalid Apple identityToken"
+    }),
+    rawNonce: import_zod12.z.string(),
+    name: appleNameInput.optional(),
+    email: import_zod12.z.string().email().nullable()
+  })
+});
+
+// src/modules/oauth/google/google.schemas.ts
+var import_zod13 = require("zod");
+var googleOAuthRequest = import_zod13.z.object({
+  body: import_zod13.z.object({
+    idToken: import_zod13.z.string().optional()
+  })
+});
+
+// src/modules/oauth/oauth.schemas.ts
+var import_zod14 = require("zod");
+var oAuthLoginResponseSchema = import_zod14.z.object({
+  message: import_zod14.z.string(),
+  user: import_zod14.z.string(),
+  accessToken: import_zod14.z.string(),
+  refreshToken: import_zod14.z.string().nullable(),
+  missingFields: import_zod14.z.array(import_zod14.z.string()).nullable()
+});
+var proceedLoginResponseSchema = loginResponseSchema;
+
+// src/modules/user/create/create.schemas.ts
+var import_zod15 = require("zod");
+var createUserRequest = import_zod15.z.object({
+  body: import_zod15.z.object({
+    username: import_zod15.z.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
+    fullName: import_zod15.z.preprocess(
+      // Map "", null, undefined -> "User"
+      (val) => {
+        if (val == null) return "User";
+        if (typeof val === "string" && val.trim() === "") return "User";
+        return val;
+      },
+      import_zod15.z.string().trim().max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only")
+    ),
+    email: import_zod15.z.string().trim().toLowerCase().email("Invalid email format"),
+    password: import_zod15.z.string().min(8, "Password must be at least 8 characters long"),
+    gender: import_zod15.z.preprocess(
+      (val) => val === "" || val == null ? "Unknown" : val,
+      import_zod15.z.enum(["Male", "Female", "Other", "Unknown"])
+    )
+  })
+});
+var createUserUserSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  username: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  email: import_zod15.z.string().nullable(),
+  gender: import_zod15.z.string(),
+  role: import_zod15.z.string(),
+  created_at: import_zod15.z.string()
+});
+var createUserResponseSchema = import_zod15.z.object({
+  message: import_zod15.z.string(),
+  user: createUserUserSchema
+});
+
+// src/modules/user/push-tokens/push-tokens.schemas.ts
+var import_zod16 = require("zod");
+var saveUserPushTokenRequest = import_zod16.z.object({
+  body: import_zod16.z.object({
+    token: import_zod16.z.string()
+  })
+});
+
+// src/modules/video-analysis/video-analysis.schemas.ts
+var import_zod17 = require("zod");
+var getPresignedUrlS3Request = import_zod17.z.object({
+  body: import_zod17.z.object({
+    exercise: import_zod17.z.string(),
+    fileType: import_zod17.z.string(),
+    jobId: import_zod17.z.string()
+  })
+});
+var getPresignedUrlFromS3ResponseSchema = import_zod17.z.object({
+  uploadUrl: import_zod17.z.string(),
+  fileKey: import_zod17.z.string(),
+  requestId: import_zod17.z.string()
+});
+
+// src/modules/web-sockets/web-sockets.schemas.ts
+var import_zod18 = require("zod");
+var generateTicketRequest = import_zod18.z.object({
+  body: import_zod18.z.object({
+    username: import_zod18.z.string()
+  })
+});
+var generateTicketResponseSchema = import_zod18.z.object({
+  ticket: import_zod18.z.string()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAerobicsRequest,
+  addWorkoutRequest,
+  addWorkoutResponseSchema,
+  adherenceExerciseStatsSchema,
+  aerobicsDailyRecordSchema,
+  aerobicsWeeklyRecordSchema,
+  allUserMessageSchema,
+  appleOAuthRequest,
+  bootstrapRequest,
+  bootstrapResponseSchema,
+  changeEmailAndVerifyRequest,
+  checkUserVerifyRequest,
+  createUserRequest,
+  createUserResponseSchema,
+  createUserUserSchema,
+  deleteMessageRequest,
+  deleteMessageResponseSchema,
+  deleteProfilePicRequest,
+  deletedMessageSchema,
+  exerciseInPlanSchema,
+  exerciseMetadataSchema,
+  exerciseTrackingAnalysisSchema,
+  exerciseTrackingAndStatsSchema,
+  exerciseTrackingPrMaxSchema,
+  finishUserWorkoutResponseSchema,
+  finishWorkoutRequest,
+  generateTicketRequest,
+  generateTicketResponseSchema,
+  getAerobicsRequest,
+  getAllExercisesResponseSchema,
+  getAllMessagesRequest,
+  getAllUserMessagesResponseSchema,
+  getAnalyticsResponseSchema,
+  getAuthenticatedUserByIdResponseSchema,
+  getExerciseTrackingRequest,
+  getExerciseTrackingResponseSchema,
+  getPresignedUrlFromS3ResponseSchema,
+  getPresignedUrlS3Request,
+  getWholeUserWorkoutPlanResponseSchema,
+  getWholeWorkoutPlanRequest,
+  googleOAuthRequest,
+  loginRequest,
+  loginResponseSchema,
+  logoutResponseSchema,
+  markMessageAsReadRequest,
+  markMessageAsReadResponseSchema,
+  messageAsReadSchema,
+  oAuthLoginResponseSchema,
+  proceedLoginResponseSchema,
+  refreshTokenResponseSchema,
+  resetPasswordRequest,
+  resetPasswordResponseSchema,
+  saveUserPushTokenRequest,
+  sendChangePassEmailRequest,
+  sendVerificationMailRequest,
+  setProfilePicAndUpdateDBResponseSchema,
+  trackingByDateItemSchema,
+  trackingBySplitNameItemSchema,
+  trackingMapItemSchema,
+  updateAuthenticatedUserResponseSchema,
+  updateUserRequest,
+  userAerobicsResponseSchema,
+  userDataResponseSchema,
+  userDataSchema,
+  verifyAccountRequest,
+  weeklyDataSchema,
+  wholeUserWorkoutPlanSchema,
+  workoutRmRecordSchema,
+  workoutSplitSchema,
+  workoutSplitsMapItemSchema,
+  workoutSplitsMapSchema
+});