@kimdaegyu/babmukdang-shared 1.1.10 → 2.0.2

package/dist/domain/common/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -34,6 +35,11 @@ __export(common_exports, {
   ApiResponseSchema: () => ApiResponseSchema,
   ApiSuccessSchema: () => ApiSuccessSchema,
   ArticleIdSchema: () => ArticleIdSchema,
+  CACHE_INVALIDATION_SSE_EVENT: () => CACHE_INVALIDATION_SSE_EVENT,
+  CacheInvalidationActionSchema: () => CacheInvalidationActionSchema,
+  CacheInvalidationEntitySchema: () => CacheInvalidationEntitySchema,
+  CacheInvalidationEventSchema: () => CacheInvalidationEventSchema,
+  CacheInvalidationKeySchema: () => CacheInvalidationKeySchema,
   CommentIdSchema: () => CommentIdSchema,
   CouponIdSchema: () => CouponIdSchema,
   CreatedEntityIdResponseSchema: () => CreatedEntityIdResponseSchema,
@@ -43,7 +49,16 @@ __export(common_exports, {
   FriendRequestIdSchema: () => FriendRequestIdSchema,
   ISODateStringSchema: () => ISODateStringSchema,
   ISODateTimeStringSchema: () => ISODateTimeStringSchema,
-  InvitationIdSchema: () => InvitationIdSchema,
+  MealGroupIdSchema: () => MealGroupIdSchema,
+  MealPlanChangeRequestIdSchema: () => MealPlanChangeRequestIdSchema,
+  MealPlanChatMessageIdSchema: () => MealPlanChatMessageIdSchema,
+  MealPlanChatRoomIdSchema: () => MealPlanChatRoomIdSchema,
+  MealPlanIdSchema: () => MealPlanIdSchema,
+  MealPlanInviteIdSchema: () => MealPlanInviteIdSchema,
+  MealPlanJoinRequestIdSchema: () => MealPlanJoinRequestIdSchema,
+  MealPlanNearbyFriendExposureBatchIdSchema: () => MealPlanNearbyFriendExposureBatchIdSchema,
+  MealPlanShareLinkIdSchema: () => MealPlanShareLinkIdSchema,
+  MealPlanShareLinkTokenSchema: () => MealPlanShareLinkTokenSchema,
   MemberIdSchema: () => MemberIdSchema,
   NoBodySchema: () => NoBodySchema,
   NoContentSchema: () => NoContentSchema,
@@ -53,12 +68,9 @@ __export(common_exports, {
   PageMetaSchema: () => PageMetaSchema,
   PageQuerySchema: () => PageQuerySchema,
   PageResponseSchema: () => PageResponseSchema,
-  PlanIdSchema: () => PlanIdSchema,
   PositiveIntIdSchema: () => PositiveIntIdSchema,
-  RecruitIdSchema: () => RecruitIdSchema,
   ReferralCodeSchema: () => ReferralCodeSchema,
   RestaurantIdSchema: () => RestaurantIdSchema,
-  RoomIdSchema: () => RoomIdSchema,
   SortDirectionSchema: () => SortDirectionSchema,
   SubscriptionIdSchema: () => SubscriptionIdSchema,
   TimeHHmmStringSchema: () => TimeHHmmStringSchema,
@@ -71,19 +83,25 @@ __export(common_exports, {
   toCommentId: () => toCommentId,
   toCouponId: () => toCouponId,
   toFriendRequestId: () => toFriendRequestId,
-  toInvitationId: () => toInvitationId,
+  toMealGroupId: () => toMealGroupId,
+  toMealPlanChangeRequestId: () => toMealPlanChangeRequestId,
+  toMealPlanChatMessageId: () => toMealPlanChatMessageId,
+  toMealPlanChatRoomId: () => toMealPlanChatRoomId,
+  toMealPlanId: () => toMealPlanId,
+  toMealPlanInviteId: () => toMealPlanInviteId,
+  toMealPlanJoinRequestId: () => toMealPlanJoinRequestId,
+  toMealPlanNearbyFriendExposureBatchId: () => toMealPlanNearbyFriendExposureBatchId,
+  toMealPlanShareLinkId: () => toMealPlanShareLinkId,
+  toMealPlanShareLinkToken: () => toMealPlanShareLinkToken,
   toMemberId: () => toMemberId,
-  toPlanId: () => toPlanId,
-  toRecruitId: () => toRecruitId,
   toReferralCode: () => toReferralCode,
   toRestaurantId: () => toRestaurantId,
-  toRoomId: () => toRoomId,
   toSubscriptionId: () => toSubscriptionId
 });
 module.exports = __toCommonJS(common_exports);
 
 // src/domain/common/contracts/api.ts
-var import_zod20 = require("zod");
+var import_zod28 = require("zod");
 
 // src/domain/article/article.schema.ts
 var import_zod7 = require("zod");
@@ -92,7 +110,10 @@ var import_zod7 = require("zod");
 var import_zod = require("zod");
 var isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
 var ISODateStringSchema = import_zod.z.string().regex(isoDateRegex, "Expected ISO date string in YYYY-MM-DD format");
-var ISODateTimeStringSchema = import_zod.z.string().datetime({ offset: true, message: "Expected ISO datetime string" });
+var ISODateTimeStringSchema = import_zod.z.string().datetime({
+  offset: true,
+  message: "Expected ISO datetime string"
+});
 var TimeHHmmStringSchema = import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Expected time string in HH:mm format");
 
 // src/domain/common/schema/id.schema.ts
@@ -103,10 +124,16 @@ var MemberIdSchema = PositiveIntIdSchema.brand();
 var UserIdSchema = MemberIdSchema;
 var ArticleIdSchema = PositiveIntIdSchema.brand();
 var CommentIdSchema = PositiveIntIdSchema.brand();
-var RecruitIdSchema = PositiveIntIdSchema.brand();
-var PlanIdSchema = PositiveIntIdSchema.brand();
-var InvitationIdSchema = PositiveIntIdSchema.brand();
-var RoomIdSchema = NonEmptyStringIdSchema.brand();
+var MealPlanIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanInviteIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanJoinRequestIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureBatchIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanChangeRequestIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanShareLinkIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanShareLinkTokenSchema = import_zod2.z.string().min(8).max(128).brand();
+var MealPlanChatRoomIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanChatMessageIdSchema = import_zod2.z.string().uuid().brand();
+var MealGroupIdSchema = import_zod2.z.string().uuid().brand();
 var RestaurantIdSchema = NonEmptyStringIdSchema.brand();
 var CouponIdSchema = PositiveIntIdSchema.brand();
 var SubscriptionIdSchema = PositiveIntIdSchema.brand();
@@ -133,11 +160,14 @@ var PageMetaSchema = import_zod3.z.object({
   hasNext: import_zod3.z.boolean(),
   hasPrevious: import_zod3.z.boolean()
 });
-var PageResponseSchema = (item) => import_zod3.z.object({
+var PageResponseSchema = /* @__PURE__ */ __name((item) => import_zod3.z.object({
   items: import_zod3.z.array(item),
   meta: PageMetaSchema
-});
-var SortDirectionSchema = import_zod3.z.enum(["asc", "desc"]);
+}), "PageResponseSchema");
+var SortDirectionSchema = import_zod3.z.enum([
+  "asc",
+  "desc"
+]);
 
 // src/domain/member/member.schema.ts
 var import_zod5 = require("zod");
@@ -154,7 +184,66 @@ var UploadPresignImageRequestSchema = import_zod4.default.object({
 });
 
 // src/domain/member/member.schema.ts
-var MemberRoleSchema = import_zod5.z.enum(["USER", "ADMIN"]);
+var MemberRoleSchema = import_zod5.z.enum([
+  "USER",
+  "ADMIN"
+]);
+var LocationConsentStatusSchema = import_zod5.z.enum([
+  "UNKNOWN",
+  "GRANTED",
+  "DENIED"
+]);
+var OnboardingStatusSchema = import_zod5.z.enum([
+  "REQUIRED",
+  "COMPLETED"
+]);
+var PermissionKindSchema = import_zod5.z.enum([
+  "LOCATION",
+  "NOTIFICATION",
+  "CAMERA"
+]);
+var PermissionStatusSchema = import_zod5.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED",
+  "LIMITED",
+  "UNSUPPORTED"
+]);
+var PermissionPlatformSchema = import_zod5.z.enum([
+  "WEB",
+  "IOS",
+  "ANDROID",
+  "UNKNOWN"
+]);
+var DevicePermissionSnapshotSchema = import_zod5.z.object({
+  kind: PermissionKindSchema,
+  status: PermissionStatusSchema,
+  platform: PermissionPlatformSchema.default("UNKNOWN"),
+  canAskAgain: import_zod5.z.boolean().optional(),
+  checkedAt: import_zod5.z.string().datetime()
+});
+var MemberLocationSchema = import_zod5.z.object({
+  latitude: import_zod5.z.number().min(-90).max(90),
+  longitude: import_zod5.z.number().min(-180).max(180),
+  accuracyMeters: import_zod5.z.number().min(0).nullable().optional(),
+  capturedAt: import_zod5.z.string().datetime()
+});
+var UpdateMemberLocationRequestSchema = MemberLocationSchema;
+var UpdateMemberLocationConsentRequestSchema = import_zod5.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().default(false),
+  mealSuggestionAllowed: import_zod5.z.boolean().optional(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.optional()
+});
+var MemberLocationSettingsResponseSchema = import_zod5.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean(),
+  mealSuggestionAllowed: import_zod5.z.boolean(),
+  lastKnownLocation: MemberLocationSchema.nullable(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.nullable().optional(),
+  updatedAt: import_zod5.z.string().datetime().nullable()
+});
 var MemberCoreSchema = import_zod5.z.object({
   memberId: MemberIdSchema,
   username: import_zod5.z.string().min(1).max(50),
@@ -166,6 +255,11 @@ var MemberResponseSchema = MemberCoreSchema.pick({
   memberId: true,
   username: true,
   profileImageUrl: true
+}).extend({
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod5.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.optional(),
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().optional()
 });
 var MemberSearchQuerySchema = import_zod5.z.object({
   email: import_zod5.z.string().email().optional(),
@@ -176,7 +270,11 @@ var MemberDetailSchema = MemberCoreSchema.extend({
   bio: import_zod5.z.string().nullable(),
   friendConunt: import_zod5.z.number().int().min(0).default(0),
   completedPlans: import_zod5.z.number().int().min(0).default(0),
-  uncompletedPlans: import_zod5.z.number().int().min(0).default(0)
+  uncompletedPlans: import_zod5.z.number().int().min(0).default(0),
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod5.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.default("UNKNOWN"),
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().default(false)
 });
 var FoodPreferenceItemSchema = FoodSchema.extend({});
 var MemberFoodPreferenceSchema = import_zod5.z.object({
@@ -191,9 +289,16 @@ var UpdateProfileRequestSchema = import_zod5.z.object({
   bio: import_zod5.z.string().max(500).nullable()
 });
 var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
-var CreateProfileRequestSchema = UpdateProfileRequestSchema.merge(
-  UpdatePreferenceRequestSchema
-);
+var CompleteOnboardingRequestSchema = UpdateProfileRequestSchema.merge(UpdatePreferenceRequestSchema);
+var OnboardingDraftSchema = import_zod5.z.object({
+  username: import_zod5.z.string().min(1).max(50).optional(),
+  profileImageUrl: import_zod5.z.string().url().nullable().optional(),
+  bio: import_zod5.z.string().max(500).nullable().optional(),
+  liked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  disliked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  allergy: import_zod5.z.array(FoodPreferenceItemSchema).optional()
+});
+var CreateProfileRequestSchema = CompleteOnboardingRequestSchema;
 
 // src/domain/restaurant/restaurant.schema.ts
 var import_zod6 = require("zod");
@@ -225,7 +330,11 @@ var KakaoPlaceRawSchema = import_zod6.z.object({
 });
 
 // src/domain/article/article.schema.ts
-var ArticleSortBySchema = import_zod7.z.enum(["createdAt", "likeCount", "commentCount"]);
+var ArticleSortBySchema = import_zod7.z.enum([
+  "createdAt",
+  "likeCount",
+  "commentCount"
+]);
 var ArticleListQuerySchema = PageQuerySchema.extend({
   sortBy: ArticleSortBySchema.optional().default("createdAt"),
   direction: SortDirectionSchema.optional().default("desc")
@@ -241,7 +350,8 @@ var CreateArticleRequestSchema = import_zod7.z.object({
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
   taggedMemberIds: import_zod7.z.array(MemberIdSchema).default([]),
-  foodAnalysis: FoodAnalysisResultSchema.optional()
+  foodAnalysis: FoodAnalysisResultSchema.optional(),
+  mealPlanId: MealPlanIdSchema.optional()
 });
 var CreateCommentRequestSchema = import_zod7.z.object({
   content: import_zod7.z.string().min(1).max(500),
@@ -261,6 +371,7 @@ var ArticleCoreSchema = import_zod7.z.object({
   imageUrl: import_zod7.z.string().url(),
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
+  mealPlanId: MealPlanIdSchema.nullable(),
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
@@ -299,63 +410,143 @@ var SignupResponseSchema = import_zod8.z.object({
   member: MemberCoreSchema
 });
 
-// src/domain/promotion/challenge.schema.ts
+// src/domain/common/schema/cache-invalidation.schema.ts
 var import_zod9 = require("zod");
-var RewardTypeSchema = import_zod9.z.enum(["WEEK", "MONTH"]);
-var WeekProgressSchema = import_zod9.z.object({
-  days: import_zod9.z.array(import_zod9.z.boolean()),
-  completed: import_zod9.z.number().int().min(0),
-  goal: import_zod9.z.number().int().positive()
-});
-var MonthProgressSchema = import_zod9.z.object({
-  count: import_zod9.z.number().int().min(0),
-  goal: import_zod9.z.number().int().positive()
-});
-var ChallengeStatusResponseSchema = import_zod9.z.object({
-  week: WeekProgressSchema,
-  month: MonthProgressSchema,
-  weekRewardAvailable: import_zod9.z.boolean(),
-  monthRewardAvailable: import_zod9.z.boolean()
-});
-var ClaimChallengeRewardRequestSchema = import_zod9.z.object({
-  type: RewardTypeSchema
-});
-var ClaimChallengeRewardResponseSchema = import_zod9.z.object({
-  rewardType: RewardTypeSchema,
-  claimed: import_zod9.z.boolean()
+var CacheInvalidationEntitySchema = import_zod9.z.enum([
+  "article",
+  "mealPlan",
+  "mealPlanInvite",
+  "mealPlanParticipant",
+  "mealPlanDecision",
+  "mealPlanChat",
+  "mealGroup",
+  "notification",
+  "friend"
+]);
+var CacheInvalidationActionSchema = import_zod9.z.enum([
+  "created",
+  "updated",
+  "deleted",
+  "accepted",
+  "rejected",
+  "cancelled",
+  "closed",
+  "joined",
+  "ready",
+  "confirmed",
+  "locked",
+  "completed",
+  "recorded",
+  "read"
+]);
+var CacheInvalidationKeySchema = import_zod9.z.enum([
+  "articles",
+  "mealPlans",
+  "mealPlanDetail",
+  "mealPlanInvites",
+  "mealPlanJoinRequests",
+  "mealPlanNearbyFriends",
+  "mealPlanMessages",
+  "mealGroups",
+  "notifications",
+  "friends",
+  "friendMeals"
+]);
+var CacheInvalidationEventSchema = import_zod9.z.object({
+  type: import_zod9.z.literal("cache.invalidate"),
+  entity: CacheInvalidationEntitySchema,
+  action: CacheInvalidationActionSchema,
+  id: import_zod9.z.union([
+    import_zod9.z.string(),
+    import_zod9.z.number()
+  ]).optional(),
+  keys: import_zod9.z.array(CacheInvalidationKeySchema).min(1),
+  occurredAt: import_zod9.z.string().datetime()
 });
 
 // src/domain/common/schema/envelope.schema.ts
 var import_zod10 = require("zod");
 var NoContentSchema = import_zod10.z.null();
-var ApiSuccessSchema = (data) => import_zod10.z.object({
+var ApiSuccessSchema = /* @__PURE__ */ __name((data) => import_zod10.z.object({
   success: import_zod10.z.literal(true),
   code: import_zod10.z.number().int(),
   message: import_zod10.z.string(),
   data
-});
+}), "ApiSuccessSchema");
 var ApiFailureSchema = import_zod10.z.object({
   success: import_zod10.z.literal(false),
   status: import_zod10.z.number().int(),
   code: import_zod10.z.string(),
   message: import_zod10.z.string()
 });
-var ApiResponseSchema = (data) => import_zod10.z.union([ApiSuccessSchema(data), ApiFailureSchema]);
+var ApiResponseSchema = /* @__PURE__ */ __name((data) => import_zod10.z.union([
+  ApiSuccessSchema(data),
+  ApiFailureSchema
+]), "ApiResponseSchema");
 var CreatedEntityIdResponseSchema = import_zod10.z.discriminatedUnion("entity", [
-  import_zod10.z.object({ entity: import_zod10.z.literal("article"), id: ArticleIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("comment"), id: CommentIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("recruit"), id: RecruitIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("invitation"), id: InvitationIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("subscription"), id: SubscriptionIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("coupon"), id: CouponIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("plan"), id: PlanIdSchema })
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("article"),
+    id: ArticleIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("comment"),
+    id: CommentIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("subscription"),
+    id: SubscriptionIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("coupon"),
+    id: CouponIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlan"),
+    id: MealPlanIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlanInvite"),
+    id: MealPlanInviteIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlanJoinRequest"),
+    id: MealPlanJoinRequestIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlanChangeRequest"),
+    id: MealPlanChangeRequestIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlanShareLink"),
+    id: MealPlanShareLinkIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealPlanChatMessage"),
+    id: MealPlanChatMessageIdSchema
+  }),
+  import_zod10.z.object({
+    entity: import_zod10.z.literal("mealGroup"),
+    id: MealGroupIdSchema
+  })
 ]);
 
 // src/domain/friend/friend.schema.ts
 var import_zod11 = require("zod");
-var FriendRequestStatusSchema = import_zod11.z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
+var FriendRequestStatusSchema = import_zod11.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELED"
+]);
+var FriendMealAvailabilitySchema = import_zod11.z.object({
+  isHungry: import_zod11.z.boolean(),
+  mealProposalAllowed: import_zod11.z.boolean(),
+  mealStatusExpiresAt: ISODateTimeStringSchema.nullable(),
+  nearbyMealPlanExposureAllowed: import_zod11.z.boolean()
+});
 var FriendListItemResponseSchema = MemberCoreSchema.extend({
-  friendSince: ISODateTimeStringSchema
+  friendSince: ISODateTimeStringSchema,
+  mealAvailability: FriendMealAvailabilitySchema.optional()
 });
 var FriendBlockItemResponseSchema = MemberCoreSchema.extend({
   blockedAt: ISODateTimeStringSchema
@@ -371,430 +562,1932 @@ var FriendRequestItemResponseSchema = import_zod11.z.object({
 var FriendSearchQuerySchema = import_zod11.z.string().min(1).max(50);
 var FriendSearchResponseSchema = import_zod11.z.array(MemberCoreSchema);
 
-// src/domain/invitation/invitation.schema.ts
-var import_zod12 = require("zod");
-var CreateInvitationRequestSchema = import_zod12.z.object({
-  inviteeId: MemberIdSchema,
-  message: import_zod12.z.string().min(1).max(500)
-});
-var InvitationListItemResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema,
-  inviterName: import_zod12.z.string(),
-  inviterProfileImageUrl: import_zod12.z.string().url().nullable().optional()
-});
-var SendInvitationResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema
-});
-var AcceptInvitationResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema,
-  room: import_zod12.z.object({
-    type: import_zod12.z.literal("invitation"),
-    roomId: RoomIdSchema
-  })
-});
-
 // src/domain/meal/meal.schema.ts
-var import_zod13 = require("zod");
-var MealStatusResponseSchema = import_zod13.z.object({
-  hungry: import_zod13.z.boolean(),
-  label: import_zod13.z.string(),
+var import_zod12 = require("zod");
+var MealStatusResponseSchema = import_zod12.z.object({
+  hungry: import_zod12.z.boolean(),
+  label: import_zod12.z.string(),
   updatedAt: ISODateStringSchema,
-  secondsToAutoOff: import_zod13.z.number().int().min(0)
+  secondsToAutoOff: import_zod12.z.number().int().min(0)
 });
-var MealStatusActionSchema = import_zod13.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
-var UpdateMealStatusRequestSchema = import_zod13.z.object({
+var MealStatusActionSchema = import_zod12.z.enum([
+  "ARTICLE_UPLOAD",
+  "SET_MANNUALY"
+]);
+var UpdateMealStatusRequestSchema = import_zod12.z.object({
   action: MealStatusActionSchema.optional().default("SET_MANNUALY")
 });
-var MealStatusSchema = import_zod13.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
-var FriendMealQuerySchema = import_zod13.z.object({
+var MealStatusSchema = import_zod12.z.enum([
+  "ALL",
+  "HUNGRY",
+  "NOT_HUNGRY"
+]);
+var FriendMealQuerySchema = import_zod12.z.object({
   status: MealStatusSchema.optional().default("ALL")
 });
 var FriendMealItemResponseSchema = MemberCoreSchema.extend({
-  hungry: import_zod13.z.boolean(),
-  label: import_zod13.z.string(),
+  hungry: import_zod12.z.boolean(),
+  label: import_zod12.z.string(),
   updatedAt: ISODateStringSchema
 });
 
-// src/domain/plan/plan.schema.ts
-var import_zod15 = require("zod");
+// src/domain/meal-plan/meal-plan.schema.ts
+var import_zod18 = require("zod");
 
-// src/domain/room/schema/room.schema.ts
-var import_zod14 = require("zod");
-var MenuCodeSchema = FoodCodeSchema;
-var LocationIdSchema = import_zod14.z.string().min(1).brand();
-var MenuSchema = FoodSchema.extend({});
-var LocationCandidateSchema = import_zod14.z.object({
-  locationId: LocationIdSchema,
-  placeName: import_zod14.z.string(),
-  lat: import_zod14.z.number(),
-  lng: import_zod14.z.number(),
-  address: import_zod14.z.string()
-});
-var ParticipantSchema = MemberCoreSchema.extend({
-  ready: import_zod14.z.boolean()
-});
-var RecruitRoomStageSchema = import_zod14.z.enum([
-  "waiting",
-  "location",
-  "location-vote",
-  "exclude-menu",
-  "menu",
-  "restaurant",
-  "finish"
+// src/domain/meal-plan/meal-plan-decision.schema.ts
+var import_zod13 = require("zod");
+var MealPlanLatitudeSchema = import_zod13.z.number().brand();
+var MealPlanLongitudeSchema = import_zod13.z.number().brand();
+var MealPlanLocationCandidateIdSchema = import_zod13.z.string().min(1).brand();
+var MealPlanMenuCandidateIdSchema = import_zod13.z.string().min(1).brand();
+var MealPlanDecisionStageIdSchema = import_zod13.z.string().uuid().brand();
+var MealPlanVoteIdSchema = import_zod13.z.string().uuid().brand();
+var MealPlanLocationCandidateSourceSchema = import_zod13.z.enum([
+  "manual",
+  "midpoint",
+  "search",
+  "recent-place",
+  "fallback"
+]);
+var MealPlanLocationCandidateSchema = import_zod13.z.object({
+  locationId: MealPlanLocationCandidateIdSchema,
+  placeName: import_zod13.z.string().min(1),
+  lat: MealPlanLatitudeSchema,
+  lng: MealPlanLongitudeSchema,
+  address: import_zod13.z.string().default(""),
+  source: MealPlanLocationCandidateSourceSchema.default("manual"),
+  createdBy: MemberIdSchema.optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanMenuCandidateSourceSchema = import_zod13.z.enum([
+  "external-recommendation",
+  "prefer-menu",
+  "recent-menu",
+  "fallback",
+  "manual-search"
+]);
+var MealPlanMenuCandidateSchema = import_zod13.z.object({
+  menuCandidateId: MealPlanMenuCandidateIdSchema,
+  menu: FoodSchema,
+  source: MealPlanMenuCandidateSourceSchema,
+  score: import_zod13.z.number().default(0),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanRestaurantCandidateSchema = RestaurantSchema.extend({
+  candidateId: RestaurantIdSchema.optional(),
+  source: import_zod13.z.enum([
+    "search",
+    "fallback",
+    "manual"
+  ]).optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanDecisionStageTypeSchema = import_zod13.z.enum([
+  "DATE",
+  "TIME",
+  "AREA",
+  "MENU",
+  "RESTAURANT",
+  "FINAL_CONFIRMATION"
 ]);
-var RoomTypeSchema = import_zod14.z.enum(["recruit", "invitation"]);
-var InvitationRoomStageSchema = import_zod14.z.enum([
-  "waiting",
+var MealPlanDecisionStageStatusSchema = import_zod13.z.enum([
+  "OPEN",
+  "COMPLETED",
+  "REOPENED"
+]);
+var MealPlanRestaurantSearchStatusSchema = import_zod13.z.enum([
+  "IDLE",
+  "PENDING",
+  "READY",
+  "FAILED",
+  "STALE"
+]);
+var MealPlanRestaurantSearchStateSchema = import_zod13.z.object({
+  searchKey: import_zod13.z.string().min(1).nullable(),
+  status: MealPlanRestaurantSearchStatusSchema,
+  startedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  version: import_zod13.z.number().int().min(0),
+  candidateCount: import_zod13.z.number().int().min(0),
+  errorMessage: import_zod13.z.string().nullable().default(null)
+});
+var MealPlanDecisionStageMetadataSchema = import_zod13.z.object({
+  restaurantSearch: MealPlanRestaurantSearchStateSchema.optional()
+}).catchall(import_zod13.z.unknown());
+var MealPlanVoteTypeSchema = import_zod13.z.enum([
+  "PICK",
+  "EXCLUDE",
+  "PREFER",
+  "READY"
+]);
+var MealPlanDecisionCandidateSchema = import_zod13.z.discriminatedUnion("stageType", [
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("DATE"),
+    value: ISODateStringSchema
+  }),
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("TIME"),
+    value: TimeHHmmStringSchema
+  }),
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("AREA"),
+    value: MealPlanLocationCandidateSchema
+  }),
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("MENU"),
+    value: MealPlanMenuCandidateSchema
+  }),
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("RESTAURANT"),
+    value: MealPlanRestaurantCandidateSchema
+  }),
+  import_zod13.z.object({
+    stageType: import_zod13.z.literal("FINAL_CONFIRMATION"),
+    value: import_zod13.z.literal("READY")
+  })
+]);
+var MealPlanVoteSchema = import_zod13.z.object({
+  voteId: MealPlanVoteIdSchema,
+  voterId: MemberIdSchema.nullable(),
+  guestId: import_zod13.z.string().min(1).nullable(),
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema,
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionStageResponseSchema = import_zod13.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanDecisionStageStatusSchema,
+  candidates: import_zod13.z.array(MealPlanDecisionCandidateSchema),
+  votes: import_zod13.z.array(MealPlanVoteSchema),
+  selectedCandidate: MealPlanDecisionCandidateSchema.nullable(),
+  metadata: MealPlanDecisionStageMetadataSchema.nullable().default(null),
+  openedAt: ISODateTimeStringSchema,
+  completedAt: ISODateTimeStringSchema.nullable(),
+  reopenedAt: ISODateTimeStringSchema.nullable()
+});
+var CreateMealPlanVoteRequestSchema = import_zod13.z.object({
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema
+});
+var CompleteMealPlanDecisionStageRequestSchema = import_zod13.z.object({
+  selectedCandidate: MealPlanDecisionCandidateSchema
+});
+var MealPlanChangeRequestStatusSchema = import_zod13.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanChangeRequestSchema = import_zod13.z.object({
+  stageType: MealPlanDecisionStageTypeSchema,
+  reason: import_zod13.z.string().min(1).max(500),
+  proposedCandidate: MealPlanDecisionCandidateSchema.optional()
+});
+var MealPlanChangeRequestSummarySchema = import_zod13.z.object({
+  changeRequestId: MealPlanChangeRequestIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanChangeRequestStatusSchema,
+  reason: import_zod13.z.string(),
+  requestedAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionTaskKeySchema = import_zod13.z.enum([
+  "SCHEDULE_DATE",
+  "SCHEDULE_TIME",
+  "LOCATION_CANDIDATE",
+  "LOCATION_VOTE",
+  "EXCLUDE_MENU",
+  "PREFER_MENU",
+  "MENU_PICK",
+  "RESTAURANT_SEARCH",
+  "RESTAURANT_PICK",
+  "FINAL_CONFIRMATION"
+]);
+var MealPlanDecisionTaskStatusSchema = import_zod13.z.enum([
+  "LOCKED",
+  "OPEN",
+  "READY",
+  "RESOLVED",
+  "STALE"
+]);
+var MealPlanDecisionFinalFieldSchema = import_zod13.z.enum([
   "date",
   "time",
-  "location",
-  "location-vote",
-  "exclude-menu",
+  "meetingAt",
+  "area",
   "menu",
-  "restaurant",
-  "finish"
-]);
-var ReadyStateRequestSchema = import_zod14.z.object({
-  isReady: import_zod14.z.boolean()
-});
-var ChatMessageRequestSchema = import_zod14.z.object({
-  message: import_zod14.z.string().min(1).max(500)
-});
-var VoteLocationRequestSchema = import_zod14.z.object({ locationId: LocationIdSchema });
-var ExcludeMenuRequestSchema = import_zod14.z.object({ menu: MenuSchema });
-var PickMenuRequestSchema = import_zod14.z.object({ menuCode: MenuCodeSchema });
-var PickRestaurantRequestSchema = import_zod14.z.object({ restaurantId: RestaurantIdSchema });
-var PickTimesRequestSchema = import_zod14.z.object({ times: import_zod14.z.array(import_zod14.z.string().min(1)).min(1) });
-var PickDateRequestSchema = import_zod14.z.object({ dates: import_zod14.z.array(ISODateStringSchema).min(1) });
-var RoomAssignedResponseSchema = import_zod14.z.object({
-  roomId: RoomIdSchema
-});
-var RoomAccessResponseSchema = import_zod14.z.object({
-  roomId: RoomIdSchema,
-  roomType: RoomTypeSchema,
-  stage: import_zod14.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
-  canJoin: import_zod14.z.boolean()
-});
-var MatchingNotificationKindSchema = import_zod14.z.enum(["recruit", "invitation"]);
-var MatchingNotificationSchema = import_zod14.z.object({
-  notificationId: import_zod14.z.string().min(1),
-  kind: MatchingNotificationKindSchema,
-  roomId: RoomIdSchema,
-  roomType: RoomTypeSchema,
-  title: import_zod14.z.string().min(1),
-  message: import_zod14.z.string().min(1),
+  "restaurant"
+]);
+var MealPlanDecisionSnapshotStatusSchema = import_zod13.z.enum([
+  "CANDIDATE",
+  "PROVISIONAL",
+  "FINAL",
+  "STALE"
+]);
+var MealPlanDecisionReasonSchema = import_zod13.z.enum([
+  "COMMON_SCHEDULE",
+  "TOP_VOTED_LOCATION",
+  "TOP_PICKED_MENU",
+  "TOP_PICKED_RESTAURANT",
+  "OWNER_CONFIRMED",
+  "TASK_ALL_READY",
+  "MANUAL_SELECTION"
+]);
+var MealPlanDecisionActorTypeSchema = import_zod13.z.enum([
+  "MEMBER",
+  "GUEST",
+  "SYSTEM"
+]);
+var MealPlanDecisionSnapshotSchema = import_zod13.z.object({
+  snapshotId: import_zod13.z.string().uuid(),
+  mealPlanId: import_zod13.z.string().uuid(),
+  field: MealPlanDecisionFinalFieldSchema,
+  value: import_zod13.z.unknown(),
+  status: MealPlanDecisionSnapshotStatusSchema,
+  reason: MealPlanDecisionReasonSchema,
+  score: import_zod13.z.number().nullable().default(null),
+  sourceEvent: import_zod13.z.string().min(1),
+  sourceActorType: MealPlanDecisionActorTypeSchema,
+  sourceMemberId: MemberIdSchema.nullable(),
+  sourceGuestId: import_zod13.z.string().min(1).nullable(),
+  sourceParticipantId: import_zod13.z.string().uuid().nullable(),
+  sourceVersion: import_zod13.z.number().int().min(0),
+  dependencyHash: import_zod13.z.string().min(1),
+  dependencyFields: import_zod13.z.array(MealPlanDecisionFinalFieldSchema),
   createdAt: ISODateTimeStringSchema,
-  readAt: ISODateTimeStringSchema.nullable()
+  staleAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanDecisionTaskProgressSchema = import_zod13.z.object({
+  taskKey: MealPlanDecisionTaskKeySchema,
+  status: MealPlanDecisionTaskStatusSchema,
+  readyCount: import_zod13.z.number().int().min(0),
+  participantCount: import_zod13.z.number().int().min(0),
+  blockers: import_zod13.z.array(import_zod13.z.string()).default([]),
+  updatedAt: ISODateTimeStringSchema
 });
-var RoomSocketErrorSchema = import_zod14.z.object({
-  code: import_zod14.z.string(),
-  message: import_zod14.z.string()
+var MealPlanDecisionProgressSchema = import_zod13.z.object({
+  mealPlanId: import_zod13.z.string().uuid(),
+  status: import_zod13.z.string().min(1),
+  tasks: import_zod13.z.array(MealPlanDecisionTaskProgressSchema),
+  final: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()),
+  provisional: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()),
+  snapshots: import_zod13.z.array(MealPlanDecisionSnapshotSchema),
+  version: import_zod13.z.number().int().min(0),
+  updatedAt: ISODateTimeStringSchema
 });
-var ChatMessageResponseSchema = import_zod14.z.object({
-  messageId: import_zod14.z.string(),
-  user: MemberCoreSchema,
-  message: import_zod14.z.string(),
-  createdAt: ISODateTimeStringSchema
+var MealPlanDecisionTaskReadyRequestSchema = import_zod13.z.object({
+  isReady: import_zod13.z.boolean()
 });
-var ReadyStateChangedSchema = import_zod14.z.object({
-  readyCount: import_zod14.z.number().int().min(0),
-  participantCount: import_zod14.z.number().int().min(0)
-});
-var FinalStateSchema = import_zod14.z.object({
-  location: LocationCandidateSchema.optional(),
-  excludeMenu: import_zod14.z.array(MenuSchema).optional(),
-  menu: MenuSchema.optional(),
-  restaurant: RestaurantSchema.optional(),
-  time: import_zod14.z.string().optional(),
-  date: ISODateStringSchema.optional()
-});
-var RoomInitialStateSchema = import_zod14.z.object({
-  participants: import_zod14.z.array(ParticipantSchema),
-  chat: import_zod14.z.array(ChatMessageResponseSchema),
-  final: FinalStateSchema
-});
-var TimePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, times: import_zod14.z.array(import_zod14.z.string()) })
-);
-var DatePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, dates: import_zod14.z.array(ISODateStringSchema) })
-);
-var LocationCandidateAddUpdateResponseSchema = import_zod14.z.array(
-  LocationCandidateSchema.extend({ authorMemberId: MemberIdSchema })
-);
-var LocationCandidateVoteUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ locationId: LocationIdSchema, votes: import_zod14.z.array(MemberIdSchema) })
-);
-var ExcludeMenuUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, exclusions: import_zod14.z.array(MenuSchema) })
-);
-var MenuPickUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
-);
-var RestaurantPickUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
-);
-var WaitingPhaseDataSchema = import_zod14.z.object({
-  locationInitial: import_zod14.z.string().optional(),
-  meetingAt: ISODateTimeStringSchema.optional()
-});
-var LocationVotePhaseDataSchema = import_zod14.z.object({
-  locations: LocationCandidateAddUpdateResponseSchema,
-  votes: LocationCandidateVoteUpdateResponseSchema
-});
-var ExcludeMenuPhaseDataSchema = import_zod14.z.object({
-  recentMenus: import_zod14.z.array(import_zod14.z.object({ userId: import_zod14.z.string(), menuList: import_zod14.z.array(MenuSchema) })),
-  excludedMenuList: ExcludeMenuUpdateResponseSchema
-});
-var MenuPhaseDataSchema = import_zod14.z.object({
-  initialMenus: import_zod14.z.array(MenuSchema),
-  menuPick: MenuPickUpdateResponseSchema
-});
-var RestaurantPhaseDataSchema = import_zod14.z.object({
-  initialRestaurants: import_zod14.z.array(RestaurantSchema),
-  restaurantUserList: RestaurantPickUpdateResponseSchema
-});
-var PhaseDataBroadcastSchema = import_zod14.z.discriminatedUnion("phase", [
-  import_zod14.z.object({ phase: import_zod14.z.literal("waiting"), data: WaitingPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("date"), data: DatePicksUpdateResponseSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("time"), data: TimePicksUpdateResponseSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("location"), data: WaitingPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("location-vote"), data: LocationVotePhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("exclude-menu"), data: ExcludeMenuPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("menu"), data: MenuPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("restaurant"), data: RestaurantPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("finish"), data: WaitingPhaseDataSchema })
-]);
-
-// src/domain/plan/plan.schema.ts
-var PlanStatusSchema = import_zod15.z.enum(["PLANNING", "COMPLETED"]);
-var PlanTypeSchema = import_zod15.z.enum(["RECRUIT", "INVITATION"]);
-var PlanResponseSchema = import_zod15.z.object({
-  planId: PlanIdSchema,
-  meetingAt: ISODateTimeStringSchema,
-  location: LocationCandidateSchema.nullable(),
-  restaurant: RestaurantSchema.nullable(),
-  author: MemberCoreSchema,
-  participants: import_zod15.z.array(MemberCoreSchema),
-  status: PlanStatusSchema,
-  type: PlanTypeSchema,
+var ReopenMealPlanDecisionTaskRequestSchema = import_zod13.z.object({
+  reason: import_zod13.z.string().max(500).optional()
+});
+var ConfirmMealPlanDecisionSnapshotRequestSchema = import_zod13.z.object({
+  snapshotId: import_zod13.z.string().uuid()
+});
+
+// src/domain/meal-plan/meal-plan-participant.schema.ts
+var import_zod14 = require("zod");
+var MealPlanParticipantIdSchema = import_zod14.z.string().uuid().brand();
+var MealPlanParticipantRoleSchema = import_zod14.z.enum([
+  "OWNER",
+  "FRIEND",
+  "GUEST"
+]);
+var MealPlanParticipantStatusSchema = import_zod14.z.enum([
+  "INVITED",
+  "REQUESTED",
+  "JOINED",
+  "READY",
+  "DECLINED",
+  "LEFT",
+  "REMOVED"
+]);
+var MealPlanJoinSourceSchema = import_zod14.z.enum([
+  "OWNER",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+var MealPlanGuestParticipantSchema = import_zod14.z.object({
+  guestId: import_zod14.z.string().min(1),
+  nickname: import_zod14.z.string().min(1).max(50)
+});
+var MealPlanParticipantResponseSchema = import_zod14.z.object({
+  participantId: MealPlanParticipantIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  member: MemberCoreSchema.nullable(),
+  guest: MealPlanGuestParticipantSchema.nullable(),
+  role: MealPlanParticipantRoleSchema,
+  status: MealPlanParticipantStatusSchema,
+  source: MealPlanJoinSourceSchema,
+  joinedAt: ISODateTimeStringSchema.nullable(),
+  readyAt: ISODateTimeStringSchema.nullable()
+});
+var CreateMealPlanParticipantRequestSchema = import_zod14.z.object({
+  memberId: MemberIdSchema.optional(),
+  guestNickname: import_zod14.z.string().min(1).max(50).optional(),
+  source: MealPlanJoinSourceSchema
+});
+
+// src/domain/meal-plan/meal-plan-invite.schema.ts
+var import_zod15 = require("zod");
+var MealPlanInviteStatusSchema = import_zod15.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "DECLINED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var CreateMealPlanInviteRequestSchema = import_zod15.z.object({
+  inviteeId: MemberIdSchema,
+  message: import_zod15.z.string().max(500).default("")
+});
+var MealPlanInviteSummarySchema = import_zod15.z.object({
+  inviteId: MealPlanInviteIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  inviter: MemberCoreSchema,
+  invitee: MemberCoreSchema,
+  status: MealPlanInviteStatusSchema,
+  message: import_zod15.z.string().max(500),
   createdAt: ISODateTimeStringSchema,
-  updatedAt: ISODateTimeStringSchema
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanInviteListResponseSchema = import_zod15.z.array(MealPlanInviteSummarySchema);
+var SendMealPlanInviteResponseSchema = import_zod15.z.object({
+  inviteId: MealPlanInviteIdSchema
 });
-var PlanListQuerySchema = import_zod15.z.object({});
 
-// src/domain/recruit/recruit.schema.ts
+// src/domain/meal-plan/meal-plan-nearby-friend.schema.ts
 var import_zod16 = require("zod");
-var RecruitStatusSchema = import_zod16.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
-var RecruitParticipantSchema = MemberCoreSchema.extend({});
-var RecruitSortBySchema = import_zod16.z.enum(["createdAt", "deadline", "participantCount"]);
-var RecruitListQuerySchema = PageQuerySchema.extend({
-  sortBy: RecruitSortBySchema.default("createdAt"),
-  direction: SortDirectionSchema.default("desc")
-});
-var RecruitResponseSchema = import_zod16.z.object({
-  targetCount: import_zod16.z.number().int().min(2),
-  meetingAt: ISODateTimeStringSchema,
-  location: import_zod16.z.string().min(1),
+var MealPlanNearbyFriendExposureIdSchema = import_zod16.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureStatusSchema = import_zod16.z.enum([
+  "OPEN",
+  "CLOSED",
+  "EXPIRED"
+]);
+var MealPlanNearbyFriendExposureNotificationStatusSchema = import_zod16.z.enum([
+  "PENDING",
+  "SENT",
+  "PARTIAL",
+  "FAILED",
+  "SKIPPED"
+]);
+var ExposeMealPlanToNearbyFriendsRequestSchema = import_zod16.z.object({
+  radiusMeters: import_zod16.z.number().int().min(100).max(5e3).default(1e3),
+  expiresAt: ISODateTimeStringSchema.optional()
+});
+var NearbyFriendExposureEligibilitySchema = import_zod16.z.object({
+  canExpose: import_zod16.z.boolean(),
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod16.z.boolean(),
+  mealSuggestionAllowed: import_zod16.z.boolean(),
+  hasLastKnownLocation: import_zod16.z.boolean(),
+  missingRequirements: import_zod16.z.array(import_zod16.z.enum([
+    "LOCATION_PERMISSION",
+    "SERVICE_LOCATION_CONSENT",
+    "NEARBY_EXPOSURE_TOGGLE",
+    "MEAL_SUGGESTION_TOGGLE",
+    "LAST_KNOWN_LOCATION"
+  ]))
+});
+var MealPlanNearbyFriendRejectionReasonSchema = import_zod16.z.enum([
+  "NOT_FRIEND",
+  "BLOCKED",
+  "LOCATION_CONSENT_REQUIRED",
+  "LOCATION_UNAVAILABLE",
+  "OUT_OF_RADIUS",
+  "MEAL_SUGGESTION_DISABLED",
+  "NOT_HUNGRY"
+]);
+var MealPlanNearbyFriendRejectionSummarySchema = import_zod16.z.object({
+  reason: MealPlanNearbyFriendRejectionReasonSchema,
+  count: import_zod16.z.number().int().min(0)
+});
+var ExposeMealPlanToNearbyFriendsResponseSchema = import_zod16.z.object({
+  mealPlanId: MealPlanIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  exposedFriendCount: import_zod16.z.number().int().min(0),
+  rejectedFriendCount: import_zod16.z.number().int().min(0),
+  notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
+  rejectionSummary: import_zod16.z.array(MealPlanNearbyFriendRejectionSummarySchema)
+});
+var MealPlanNearbyFriendExposureSummarySchema = import_zod16.z.object({
+  exposureId: MealPlanNearbyFriendExposureIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema.nullable(),
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  radiusMeters: import_zod16.z.number().int().min(100),
+  exposedFriendCount: import_zod16.z.number().int().min(0),
+  openedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  closedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanNearbyFriendExposureBatchSummarySchema = import_zod16.z.object({
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  radiusMeters: import_zod16.z.number().int().min(100),
+  exposedFriendCount: import_zod16.z.number().int().min(0),
+  rejectedFriendCount: import_zod16.z.number().int().min(0),
+  rejectionSummary: import_zod16.z.array(MealPlanNearbyFriendRejectionSummarySchema),
+  notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
+  notificationSentAt: ISODateTimeStringSchema.nullable(),
+  openedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  closedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanJoinRequestStatusSchema = import_zod16.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanJoinRequestSchema = import_zod16.z.object({
+  message: import_zod16.z.string().max(500).default("")
+});
+var MealPlanJoinRequestSummarySchema = import_zod16.z.object({
+  joinRequestId: MealPlanJoinRequestIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  requester: MemberCoreSchema,
+  status: MealPlanJoinRequestStatusSchema,
   message: import_zod16.z.string().max(500),
-  recruitId: RecruitIdSchema,
-  status: RecruitStatusSchema,
+  requestedAt: ISODateTimeStringSchema,
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+var NearbyFriendMealPlanSummarySchema = import_zod16.z.object({
+  mealPlanId: MealPlanIdSchema,
+  owner: MemberCoreSchema,
+  title: import_zod16.z.string(),
+  participantCount: import_zod16.z.number().int().min(1),
+  distanceMeters: import_zod16.z.number().int().min(0),
+  exposedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  joinRequestStatus: MealPlanJoinRequestStatusSchema.nullable().default(null)
+});
+
+// src/domain/meal-plan/meal-plan-chat.schema.ts
+var import_zod17 = require("zod");
+var MealPlanChatMessageKindSchema = import_zod17.z.enum([
+  "USER",
+  "SYSTEM"
+]);
+var MealPlanSystemMessageKindSchema = import_zod17.z.enum([
+  "PARTICIPANT_JOINED",
+  "PARTICIPANT_READY",
+  "PARTICIPANT_REMOVED",
+  "STATUS_CHANGED",
+  "DECISION_UPDATED",
+  "CONFIRMED",
+  "RECORD_NEEDED"
+]);
+var MealPlanChatSystemPayloadSchema = import_zod17.z.object({
+  kind: MealPlanSystemMessageKindSchema
+}).catchall(import_zod17.z.unknown());
+var MealPlanChatMessageListResponseSchema = import_zod17.z.array(import_zod17.z.lazy(() => MealPlanChatMessageResponseSchema));
+var MealPlanChatRoomSummarySchema = import_zod17.z.object({
+  chatRoomId: MealPlanChatRoomIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  messageCount: import_zod17.z.number().int().min(0),
+  lastMessageAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var SendMealPlanChatMessageRequestSchema = import_zod17.z.object({
+  message: import_zod17.z.string().min(1).max(500)
+});
+var MealPlanChatMessageResponseSchema = import_zod17.z.object({
+  messageId: MealPlanChatMessageIdSchema,
+  chatRoomId: MealPlanChatRoomIdSchema,
+  sender: MemberCoreSchema.nullable(),
+  guestId: import_zod17.z.string().min(1).nullable(),
+  guestNickname: import_zod17.z.string().min(1).nullable(),
+  kind: MealPlanChatMessageKindSchema,
+  message: import_zod17.z.string().min(1).max(1e3),
+  systemPayload: MealPlanChatSystemPayloadSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSystemMessageSchema = import_zod17.z.object({
+  kind: MealPlanSystemMessageKindSchema,
+  message: import_zod17.z.string().min(1),
+  createdAt: ISODateTimeStringSchema
+});
+
+// src/domain/meal-plan/meal-plan.schema.ts
+var MealPlanStatusSchema = import_zod18.z.enum([
+  "DRAFT",
+  "RECOMMENDING",
+  "GATHERING",
+  "DECIDING",
+  "READY",
+  "CONFIRMED",
+  "LOCKED",
+  "COMPLETED",
+  "RECORDED",
+  "CANCELLED"
+]);
+var MealPlanChannelSchema = import_zod18.z.enum([
+  "OWNER_ONLY",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+var MealPlanRecommendationContextSchema = import_zod18.z.object({
+  mealDate: ISODateStringSchema.optional(),
+  mealTime: TimeHHmmStringSchema.optional(),
+  area: MealPlanLocationCandidateSchema.optional(),
+  preferredMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
+  excludedMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
+  candidateMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
+  budgetMin: import_zod18.z.number().int().min(0).optional(),
+  budgetMax: import_zod18.z.number().int().min(0).optional(),
+  memo: import_zod18.z.string().max(500).optional()
+});
+var CreateMealPlanRequestSchema = import_zod18.z.object({
+  title: import_zod18.z.string().min(1).max(100).optional(),
+  channels: import_zod18.z.array(MealPlanChannelSchema).default([
+    "OWNER_ONLY"
+  ]),
+  recommendationContext: MealPlanRecommendationContextSchema.optional()
+});
+var CreateMealPlanResponseSchema = import_zod18.z.object({
+  mealPlanId: MealPlanIdSchema
+});
+var UpdateMealPlanContextRequestSchema = MealPlanRecommendationContextSchema.partial();
+var MealPlanViewerRoleSchema = import_zod18.z.enum([
+  "OWNER",
+  "FRIEND",
+  "GUEST",
+  "NONE"
+]);
+var MealPlanViewerPermissionsSchema = import_zod18.z.object({
+  canView: import_zod18.z.boolean(),
+  canInviteFriends: import_zod18.z.boolean(),
+  canManageParticipants: import_zod18.z.boolean(),
+  canCreateShareLink: import_zod18.z.boolean(),
+  canExposeNearbyFriends: import_zod18.z.boolean(),
+  canVote: import_zod18.z.boolean(),
+  canChat: import_zod18.z.boolean(),
+  canReadyMealPlan: import_zod18.z.boolean(),
+  canReadyDecisionTask: import_zod18.z.boolean(),
+  canRequestChange: import_zod18.z.boolean(),
+  canReopenDecisionTask: import_zod18.z.boolean(),
+  canConfirmDecisionSnapshot: import_zod18.z.boolean(),
+  canConfirmMealPlan: import_zod18.z.boolean(),
+  canCompleteMealPlan: import_zod18.z.boolean(),
+  canRecordMealPlan: import_zod18.z.boolean(),
+  canCancelMealPlan: import_zod18.z.boolean()
+});
+var MealPlanResponseSchema = import_zod18.z.object({
+  mealPlanId: MealPlanIdSchema,
+  owner: MemberCoreSchema,
+  title: import_zod18.z.string().nullable(),
+  status: MealPlanStatusSchema,
+  channels: import_zod18.z.array(MealPlanChannelSchema),
+  participants: import_zod18.z.array(MealPlanParticipantResponseSchema),
+  pendingInvites: import_zod18.z.array(MealPlanInviteSummarySchema),
+  pendingJoinRequests: import_zod18.z.array(MealPlanJoinRequestSummarySchema),
+  decisionStages: import_zod18.z.array(MealPlanDecisionStageResponseSchema),
+  decisionProgress: MealPlanDecisionProgressSchema.nullable(),
+  viewerRole: MealPlanViewerRoleSchema,
+  viewerParticipantStatus: MealPlanParticipantStatusSchema.nullable(),
+  viewerPermissions: MealPlanViewerPermissionsSchema,
+  viewerTaskReadyMap: import_zod18.z.record(MealPlanDecisionTaskKeySchema, import_zod18.z.boolean()),
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  selectedArea: MealPlanLocationCandidateSchema.nullable(),
+  selectedRestaurant: RestaurantSchema.nullable(),
+  selectedMenuCategory: import_zod18.z.string().nullable(),
+  chatRoom: MealPlanChatRoomSummarySchema.nullable(),
+  confirmedAt: ISODateTimeStringSchema.nullable(),
+  lockedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  recordedAt: ISODateTimeStringSchema.nullable(),
   createdAt: ISODateTimeStringSchema,
-  expiredAt: ISODateTimeStringSchema,
-  updatedAt: ISODateTimeStringSchema,
-  author: MemberCoreSchema,
-  participants: import_zod16.z.array(RecruitParticipantSchema)
+  updatedAt: ISODateTimeStringSchema
 });
-var RecruitListResponseSchema = PageResponseSchema(RecruitResponseSchema);
-var CreateRecruitRequestSchema = import_zod16.z.object({
-  targetCount: import_zod16.z.number().int().min(2),
-  meetingAt: ISODateTimeStringSchema,
-  location: import_zod16.z.string().min(1),
-  message: import_zod16.z.string().max(500)
+var MyMealPlanGroupSchema = import_zod18.z.enum([
+  "DECIDING",
+  "UPCOMING",
+  "RECORD_NEEDED",
+  "PAST"
+]);
+var MyMealPlanListItemSchema = import_zod18.z.object({
+  mealPlanId: MealPlanIdSchema,
+  group: MyMealPlanGroupSchema,
+  title: import_zod18.z.string(),
+  status: MealPlanStatusSchema,
+  channels: import_zod18.z.array(MealPlanChannelSchema),
+  participantCount: import_zod18.z.number().int().min(1),
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  selectedAreaName: import_zod18.z.string().nullable(),
+  selectedRestaurantName: import_zod18.z.string().nullable(),
+  primaryAction: import_zod18.z.object({
+    label: import_zod18.z.string(),
+    href: import_zod18.z.string()
+  }),
+  updatedAt: ISODateTimeStringSchema
 });
-var CreateRecruitResponseSchema = import_zod16.z.object({
-  recruitId: RecruitIdSchema
+var MyMealPlanListResponseSchema = import_zod18.z.object({
+  deciding: import_zod18.z.array(MyMealPlanListItemSchema),
+  upcoming: import_zod18.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod18.z.array(MyMealPlanListItemSchema),
+  past: import_zod18.z.array(MyMealPlanListItemSchema)
+});
+var MealPlanNotificationKindSchema = import_zod18.z.enum([
+  "MEAL_PLAN_INVITE_RECEIVED",
+  "MEAL_PLAN_INVITE_ACCEPTED",
+  "MEAL_PLAN_JOIN_REQUESTED",
+  "MEAL_PLAN_JOIN_REQUEST_ACCEPTED",
+  "MEAL_PLAN_NEARBY_FRIEND_EXPOSED",
+  "MEAL_PLAN_PARTICIPANT_JOINED",
+  "MEAL_PLAN_READY_COMPLETED",
+  "MEAL_PLAN_CONFIRMED",
+  "MEAL_PLAN_LOCKED",
+  "MEAL_PLAN_RECORD_NEEDED"
+]);
+var MealPlanNotificationPriorityChannelSchema = import_zod18.z.enum([
+  "HOME",
+  "NOTIFICATION_INBOX",
+  "FCM_PUSH",
+  "LIVE_ACTIVITY"
+]);
+var MealPlanLiveActivityBehaviorSchema = import_zod18.z.enum([
+  "NONE",
+  "START_OR_UPDATE",
+  "UPDATE",
+  "END"
+]);
+var MealPlanNotificationPriorityPolicyItemSchema = import_zod18.z.object({
+  kind: MealPlanNotificationKindSchema,
+  priority: import_zod18.z.number().int().min(0),
+  homePriority: import_zod18.z.number().int().min(0),
+  inboxPriority: import_zod18.z.number().int().min(0),
+  fcmPriority: import_zod18.z.number().int().min(0),
+  liveActivityPriority: import_zod18.z.number().int().min(0),
+  liveActivityBehavior: MealPlanLiveActivityBehaviorSchema,
+  foregroundToast: import_zod18.z.boolean()
+});
+var MealPlanNotificationSchema = import_zod18.z.object({
+  notificationId: import_zod18.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  deepLink: import_zod18.z.string().min(1),
+  title: import_zod18.z.string().min(1),
+  message: import_zod18.z.string().min(1),
+  createdAt: ISODateTimeStringSchema,
+  readAt: ISODateTimeStringSchema.nullable()
+});
+
+// src/domain/meal-plan/meal-plan-share-link.schema.ts
+var import_zod19 = require("zod");
+var CreateMealPlanShareLinkRequestSchema = import_zod19.z.object({
+  expiresAt: ISODateTimeStringSchema.optional(),
+  guestJoinEnabled: import_zod19.z.boolean().default(true)
+});
+var MealPlanShareLinkSummarySchema = import_zod19.z.object({
+  shareLinkId: MealPlanShareLinkIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  url: import_zod19.z.string().url(),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod19.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSharePreviewResponseSchema = import_zod19.z.object({
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  title: import_zod19.z.string(),
+  ownerName: import_zod19.z.string(),
+  participantCount: import_zod19.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod19.z.boolean()
+});
+var JoinMealPlanGuestRequestSchema = import_zod19.z.object({
+  nickname: import_zod19.z.string().min(1).max(50),
+  password: import_zod19.z.string().min(1).max(100).optional()
+});
+var JoinMealPlanGuestResponseSchema = import_zod19.z.object({
+  mealPlanId: MealPlanIdSchema,
+  guestId: import_zod19.z.string().min(1),
+  sessionToken: import_zod19.z.string().min(1)
+});
+var MealPlanGuestSessionQuerySchema = import_zod19.z.object({
+  sessionToken: import_zod19.z.string().min(1)
+});
+var MealPlanGuestSessionResponseSchema = import_zod19.z.object({
+  mealPlan: MealPlanResponseSchema,
+  token: MealPlanShareLinkTokenSchema,
+  guestId: import_zod19.z.string().min(1),
+  nickname: import_zod19.z.string().min(1).max(50),
+  sessionToken: import_zod19.z.string().min(1)
+});
+
+// src/domain/meal-plan/meal-group.schema.ts
+var import_zod20 = require("zod");
+var MealGroupMemberRoleSchema = import_zod20.z.enum([
+  "OWNER",
+  "MEMBER"
+]);
+var MealGroupMemberSchema = import_zod20.z.object({
+  member: MemberCoreSchema,
+  role: MealGroupMemberRoleSchema,
+  joinedAt: ISODateTimeStringSchema
+});
+var MealGroupResponseSchema = import_zod20.z.object({
+  mealGroupId: MealGroupIdSchema,
+  name: import_zod20.z.string().min(1).max(50),
+  owner: MemberCoreSchema,
+  profileImageUrl: import_zod20.z.string().url().nullable(),
+  members: import_zod20.z.array(MealGroupMemberSchema),
+  recentMealPlanIds: import_zod20.z.array(MealPlanIdSchema),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var CreateMealGroupRequestSchema = import_zod20.z.object({
+  name: import_zod20.z.string().min(1).max(50),
+  memberIds: import_zod20.z.array(import_zod20.z.number().int().positive()).min(1),
+  profileImageUrl: import_zod20.z.string().url().nullable().optional(),
+  sourceMealPlanId: MealPlanIdSchema.optional()
+});
+var StartMealPlanFromGroupRequestSchema = import_zod20.z.object({
+  title: import_zod20.z.string().min(1).max(100).optional()
+});
+var AddMealGroupMemberRequestSchema = import_zod20.z.object({
+  memberId: import_zod20.z.number().int().positive(),
+  role: MealGroupMemberRoleSchema.default("MEMBER")
+});
+var UpdateMealGroupMemberRoleRequestSchema = import_zod20.z.object({
+  role: MealGroupMemberRoleSchema
+});
+var MealGroupHistoryItemSchema = MyMealPlanListItemSchema.extend({});
+var MealGroupPreferenceSummarySchema = import_zod20.z.object({
+  mealGroupId: MealGroupIdSchema,
+  frequentMenuCategories: import_zod20.z.array(import_zod20.z.object({
+    label: import_zod20.z.string(),
+    count: import_zod20.z.number().int().min(0)
+  })),
+  frequentRestaurants: import_zod20.z.array(import_zod20.z.object({
+    restaurantName: import_zod20.z.string(),
+    count: import_zod20.z.number().int().min(0)
+  })),
+  recentMenuCategories: import_zod20.z.array(import_zod20.z.string()),
+  recommendationContext: import_zod20.z.object({
+    preferredMenuCategories: import_zod20.z.array(import_zod20.z.string()),
+    excludedMenuCategories: import_zod20.z.array(import_zod20.z.string()),
+    candidateMenuCategories: import_zod20.z.array(import_zod20.z.string())
+  })
+});
+var MealGroupHistoryResponseSchema = import_zod20.z.array(MealGroupHistoryItemSchema);
+
+// src/domain/meal-plan/meal-plan-home-map.schema.ts
+var import_zod21 = require("zod");
+var HomeMealPlanActionKindSchema = import_zod21.z.enum([
+  "CONTINUE_DECISION",
+  "TODAY_UPCOMING",
+  "RECORD_NEEDED",
+  "RESPOND_JOIN_REQUEST",
+  "NOTIFICATION_FOLLOW_UP"
+]);
+var HomeMealPlanActionCardSchema = import_zod21.z.object({
+  actionId: import_zod21.z.string().min(1),
+  kind: HomeMealPlanActionKindSchema,
+  priority: import_zod21.z.number().int().min(0),
+  title: import_zod21.z.string().min(1),
+  description: import_zod21.z.string().min(1),
+  primaryAction: import_zod21.z.object({
+    label: import_zod21.z.string().min(1),
+    href: import_zod21.z.string().min(1)
+  }),
+  mealPlan: MyMealPlanListItemSchema.nullable(),
+  joinRequest: MealPlanJoinRequestSummarySchema.nullable(),
+  notification: MealPlanNotificationSchema.nullable().default(null)
+});
+var HomeMealPlanDashboardResponseSchema = import_zod21.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  inProgress: import_zod21.z.array(MyMealPlanListItemSchema),
+  today: import_zod21.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod21.z.array(MyMealPlanListItemSchema),
+  pendingJoinRequests: import_zod21.z.array(MealPlanJoinRequestSummarySchema),
+  unreadNotifications: import_zod21.z.array(MealPlanNotificationSchema).default([]),
+  nextActions: import_zod21.z.array(HomeMealPlanActionCardSchema)
+});
+var MealMapLayerSchema = import_zod21.z.enum([
+  "MY_MEAL_PLAN_PLACE",
+  "NEARBY_FRIEND_MEAL_PLAN",
+  "FRIEND_RECORD_LOCATION",
+  "RESTAURANT_CANDIDATE"
+]);
+var MealMapMarkerBaseSchema = import_zod21.z.object({
+  markerId: import_zod21.z.string().min(1),
+  lat: import_zod21.z.number().min(-90).max(90),
+  lng: import_zod21.z.number().min(-180).max(180),
+  title: import_zod21.z.string().min(1),
+  subtitle: import_zod21.z.string().nullable(),
+  href: import_zod21.z.string().min(1).nullable(),
+  mealPlanId: MealPlanIdSchema.nullable(),
+  articleId: ArticleIdSchema.nullable(),
+  restaurant: RestaurantSchema.nullable(),
+  distanceMeters: import_zod21.z.number().int().min(0).nullable(),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealMapMyMealPlanPlaceMetadataSchema = import_zod21.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod21.z.string().min(1),
+  participantCount: import_zod21.z.number().int().min(1),
+  source: import_zod21.z.string().min(1)
+});
+var MealMapNearbyFriendMealPlanMetadataSchema = import_zod21.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  ownerName: import_zod21.z.string().min(1),
+  participantCount: import_zod21.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  source: import_zod21.z.string().min(1)
+});
+var MealMapFriendRecordLocationMetadataSchema = import_zod21.z.object({
+  authorId: MemberIdSchema.nullable().default(null),
+  authorName: import_zod21.z.string().min(1),
+  imageUrl: import_zod21.z.string().nullable().default(null),
+  mealDate: import_zod21.z.string().min(1)
+});
+var MealMapRestaurantCandidateCompletionBlockedReasonSchema = import_zod21.z.enum([
+  "OWNER_ONLY",
+  "STAGE_ALREADY_COMPLETED",
+  "MEAL_PLAN_NOT_MUTABLE"
+]);
+var MealMapRestaurantCandidateMetadataSchema = import_zod21.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod21.z.string().min(1),
+  source: import_zod21.z.enum([
+    "search",
+    "fallback",
+    "manual"
+  ]).default("search"),
+  stageStatus: import_zod21.z.enum([
+    "OPEN",
+    "COMPLETED",
+    "REOPENED"
+  ]).default("OPEN"),
+  canVote: import_zod21.z.boolean().default(false),
+  canCompleteStage: import_zod21.z.boolean().default(false),
+  completionBlockedReason: MealMapRestaurantCandidateCompletionBlockedReasonSchema.nullable().default(null)
+});
+var MealMapMarkerSchema = import_zod21.z.discriminatedUnion("layer", [
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod21.z.literal("MY_MEAL_PLAN_PLACE"),
+    metadata: MealMapMyMealPlanPlaceMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod21.z.literal("NEARBY_FRIEND_MEAL_PLAN"),
+    metadata: MealMapNearbyFriendMealPlanMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod21.z.literal("FRIEND_RECORD_LOCATION"),
+    metadata: MealMapFriendRecordLocationMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod21.z.literal("RESTAURANT_CANDIDATE"),
+    metadata: MealMapRestaurantCandidateMetadataSchema
+  })
+]);
+var MealMapQuerySchema = import_zod21.z.object({
+  friendRecordDays: import_zod21.z.coerce.number().int().min(1).max(90).optional().default(7)
+});
+var MealMapResponseSchema = import_zod21.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  center: import_zod21.z.object({
+    lat: import_zod21.z.number().min(-90).max(90),
+    lng: import_zod21.z.number().min(-180).max(180),
+    source: import_zod21.z.enum([
+      "LAST_KNOWN_LOCATION",
+      "MY_MEAL_PLAN",
+      "DEFAULT"
+    ])
+  }),
+  layers: import_zod21.z.object({
+    myMealPlanPlaces: import_zod21.z.array(MealMapMarkerSchema),
+    nearbyFriendMealPlans: import_zod21.z.array(MealMapMarkerSchema),
+    friendRecordLocations: import_zod21.z.array(MealMapMarkerSchema),
+    restaurantCandidates: import_zod21.z.array(MealMapMarkerSchema)
+  })
 });
 
 // src/domain/promotion/referral.schema.ts
-var import_zod17 = require("zod");
-var ReferralCreateResponseSchema = import_zod17.z.object({
+var import_zod22 = require("zod");
+var ReferralCreateResponseSchema = import_zod22.z.object({
   code: ReferralCodeSchema,
-  link: import_zod17.z.string().url(),
+  link: import_zod22.z.string().url(),
   expiresAt: ISODateTimeStringSchema
 });
-var ReferralItemResponseSchema = import_zod17.z.object({
+var ReferralItemResponseSchema = import_zod22.z.object({
   code: ReferralCodeSchema,
   createdAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  used: import_zod17.z.boolean(),
+  used: import_zod22.z.boolean(),
   usedByMemberId: MemberIdSchema.nullable(),
-  usedByUsername: import_zod17.z.string().nullable()
+  usedByUsername: import_zod22.z.string().nullable()
 });
-var RedeemReferralRequestSchema = import_zod17.z.object({
+var RedeemReferralRequestSchema = import_zod22.z.object({
   code: ReferralCodeSchema
 });
 
 // src/domain/promotion/coupon.schema.ts
-var import_zod18 = require("zod");
-var CouponTypeSchema = import_zod18.z.enum(["DISCOUNT", "SERVICE"]);
-var CouponStatusSchema = import_zod18.z.enum(["UNUSED", "USED"]);
-var CouponResponseSchema = import_zod18.z.object({
+var import_zod23 = require("zod");
+var CouponTypeSchema = import_zod23.z.enum([
+  "DISCOUNT",
+  "SERVICE"
+]);
+var CouponStatusSchema = import_zod23.z.enum([
+  "UNUSED",
+  "USED"
+]);
+var CouponResponseSchema = import_zod23.z.object({
   couponId: CouponIdSchema,
-  title: import_zod18.z.string(),
-  shopName: import_zod18.z.string(),
+  title: import_zod23.z.string(),
+  shopName: import_zod23.z.string(),
   type: CouponTypeSchema,
-  condition: import_zod18.z.string(),
+  condition: import_zod23.z.string(),
   expiresAt: ISODateStringSchema,
-  used: import_zod18.z.boolean(),
-  thumbnailUrl: import_zod18.z.string().url()
+  used: import_zod23.z.boolean(),
+  thumbnailUrl: import_zod23.z.string().url()
+});
+
+// src/domain/promotion/challenge.schema.ts
+var import_zod24 = require("zod");
+var RewardTypeSchema = import_zod24.z.enum([
+  "WEEK",
+  "MONTH"
+]);
+var WeekProgressSchema = import_zod24.z.object({
+  days: import_zod24.z.array(import_zod24.z.boolean()),
+  completed: import_zod24.z.number().int().min(0),
+  goal: import_zod24.z.number().int().positive()
+});
+var MonthProgressSchema = import_zod24.z.object({
+  count: import_zod24.z.number().int().min(0),
+  goal: import_zod24.z.number().int().positive()
+});
+var ChallengeStatusResponseSchema = import_zod24.z.object({
+  week: WeekProgressSchema,
+  month: MonthProgressSchema,
+  weekRewardAvailable: import_zod24.z.boolean(),
+  monthRewardAvailable: import_zod24.z.boolean()
+});
+var ClaimChallengeRewardRequestSchema = import_zod24.z.object({
+  type: RewardTypeSchema
+});
+var ClaimChallengeRewardResponseSchema = import_zod24.z.object({
+  rewardType: RewardTypeSchema,
+  claimed: import_zod24.z.boolean()
+});
+
+// src/domain/push/push.schema.ts
+var import_zod25 = require("zod");
+var PushProviderSchema = import_zod25.z.enum([
+  "FCM",
+  "APNS_LIVE_ACTIVITY"
+]);
+var PushPlatformSchema = import_zod25.z.enum([
+  "WEB",
+  "ANDROID",
+  "IOS"
+]);
+var PushPermissionStatusSchema = import_zod25.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED"
+]);
+var PushTokenStatusSchema = import_zod25.z.enum([
+  "ACTIVE",
+  "REVOKED",
+  "DISABLED"
+]);
+var RegisterPushTokenRequestSchema = import_zod25.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  platform: PushPlatformSchema,
+  token: import_zod25.z.string().min(10),
+  deviceId: import_zod25.z.string().min(1).max(128),
+  appVersion: import_zod25.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod25.z.string().min(1).max(64).optional(),
+  permissionStatus: PushPermissionStatusSchema
+});
+var RevokePushTokenRequestSchema = import_zod25.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  token: import_zod25.z.string().min(10).optional(),
+  deviceId: import_zod25.z.string().min(1).max(128).optional()
+});
+var PushTokenResponseSchema = import_zod25.z.object({
+  pushTokenId: import_zod25.z.string().uuid(),
+  provider: PushProviderSchema,
+  platform: PushPlatformSchema,
+  deviceId: import_zod25.z.string(),
+  status: PushTokenStatusSchema,
+  permissionStatus: PushPermissionStatusSchema,
+  appVersion: import_zod25.z.string().nullable(),
+  buildNumber: import_zod25.z.string().nullable(),
+  lastSeenAt: ISODateTimeStringSchema,
+  revokedAt: ISODateTimeStringSchema.nullable()
+});
+var PushPayloadSchemaVersionSchema = import_zod25.z.literal("2026-06-17");
+var MealPlanPushPayloadDataSchema = import_zod25.z.object({
+  schemaVersion: PushPayloadSchemaVersionSchema,
+  notificationId: import_zod25.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  deepLink: import_zod25.z.string().min(1),
+  title: import_zod25.z.string().min(1),
+  body: import_zod25.z.string().min(1),
+  fcmPriority: import_zod25.z.coerce.number().int().min(0),
+  liveActivityPriority: import_zod25.z.coerce.number().int().min(0),
+  liveActivityBehavior: MealPlanLiveActivityBehaviorSchema
+});
+var PushDeliveryStatusSchema = import_zod25.z.enum([
+  "PENDING",
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptResultSchema = import_zod25.z.enum([
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptSummarySchema = import_zod25.z.object({
+  attemptId: import_zod25.z.string().uuid(),
+  outboxId: import_zod25.z.string().uuid(),
+  pushTokenId: import_zod25.z.string().uuid().nullable(),
+  provider: PushProviderSchema,
+  result: PushDeliveryAttemptResultSchema,
+  providerMessageId: import_zod25.z.string().nullable(),
+  errorCode: import_zod25.z.string().nullable(),
+  errorMessage: import_zod25.z.string().nullable(),
+  invalidToken: import_zod25.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var PushDeliveryOutboxSummarySchema = import_zod25.z.object({
+  outboxId: import_zod25.z.string().uuid(),
+  notificationId: import_zod25.z.string().min(1),
+  memberId: import_zod25.z.number().int().positive(),
+  status: PushDeliveryStatusSchema,
+  attemptCount: import_zod25.z.number().int().min(0),
+  lastError: import_zod25.z.string().nullable(),
+  nextAttemptAt: ISODateTimeStringSchema.nullable(),
+  sentAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+
+// src/domain/live-activity/live-activity.schema.ts
+var import_zod26 = require("zod");
+var MealPlanLiveActivityPlatformSchema = import_zod26.z.enum([
+  "IOS_LIVE_ACTIVITY",
+  "ANDROID_LIVE_UPDATE"
+]);
+var MealPlanLiveActivitySessionStatusSchema = import_zod26.z.enum([
+  "ACTIVE",
+  "ENDED",
+  "EXPIRED",
+  "DISABLED"
+]);
+var MealPlanLiveActivityUpdateStatusSchema = import_zod26.z.enum([
+  "PENDING",
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var RegisterMealPlanLiveActivitySessionRequestSchema = import_zod26.z.object({
+  platform: MealPlanLiveActivityPlatformSchema,
+  deviceId: import_zod26.z.string().min(1).max(128),
+  activityId: import_zod26.z.string().min(1).max(128),
+  pushToken: import_zod26.z.string().min(10).optional(),
+  appVersion: import_zod26.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod26.z.string().min(1).max(64).optional()
+});
+var EndMealPlanLiveActivitySessionRequestSchema = import_zod26.z.object({
+  platform: MealPlanLiveActivityPlatformSchema.optional(),
+  deviceId: import_zod26.z.string().min(1).max(128).optional(),
+  activityId: import_zod26.z.string().min(1).max(128).optional()
+});
+var MealPlanLiveActivityStateSchema = import_zod26.z.object({
+  mealPlanId: MealPlanIdSchema,
+  title: import_zod26.z.string().min(1),
+  status: import_zod26.z.string().min(1),
+  scheduledAt: ISODateTimeStringSchema.nullable(),
+  restaurantName: import_zod26.z.string().nullable(),
+  placeName: import_zod26.z.string().nullable(),
+  deepLink: import_zod26.z.string().min(1),
+  progressLabel: import_zod26.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealPlanLiveActivitySessionResponseSchema = import_zod26.z.object({
+  sessionId: import_zod26.z.string().uuid(),
+  mealPlanId: MealPlanIdSchema,
+  memberId: import_zod26.z.number().int().positive(),
+  platform: MealPlanLiveActivityPlatformSchema,
+  devicePlatform: PushPlatformSchema,
+  deviceId: import_zod26.z.string(),
+  activityId: import_zod26.z.string(),
+  status: MealPlanLiveActivitySessionStatusSchema,
+  appVersion: import_zod26.z.string().nullable(),
+  buildNumber: import_zod26.z.string().nullable(),
+  lastEventKind: MealPlanNotificationKindSchema.nullable(),
+  lastBehavior: MealPlanLiveActivityBehaviorSchema.nullable(),
+  lastUpdateStatus: MealPlanLiveActivityUpdateStatusSchema.nullable(),
+  lastError: import_zod26.z.string().nullable(),
+  startedAt: ISODateTimeStringSchema,
+  endedAt: ISODateTimeStringSchema.nullable(),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealPlanLiveActivitySessionListResponseSchema = import_zod26.z.object({
+  mealPlanId: MealPlanIdSchema,
+  state: MealPlanLiveActivityStateSchema,
+  sessions: import_zod26.z.array(MealPlanLiveActivitySessionResponseSchema)
 });
 
 // src/domain/common/contracts/endpoint.ts
-var import_zod19 = require("zod");
-var NoBodySchema = import_zod19.z.undefined();
-var NoQuerySchema = import_zod19.z.undefined();
-var NoParamsSchema = import_zod19.z.undefined();
-var endpoint = (contract) => ({
+var import_zod27 = require("zod");
+var NoBodySchema = import_zod27.z.undefined();
+var NoQuerySchema = import_zod27.z.undefined();
+var NoParamsSchema = import_zod27.z.undefined();
+var endpoint = /* @__PURE__ */ __name((contract) => ({
   method: contract.method,
   path: contract.path,
   pathParams: contract.pathParams ?? NoParamsSchema,
   query: contract.query ?? NoQuerySchema,
   body: contract.body ?? NoBodySchema,
   response: contract.response
-});
+}), "endpoint");
 
 // src/domain/common/contracts/api.ts
-var memberIdParam = import_zod20.z.object({ memberId: MemberIdSchema });
-var articleIdParam = import_zod20.z.object({ articleId: ArticleIdSchema });
-var commentIdParam = import_zod20.z.object({ commentId: CommentIdSchema });
-var recruitIdParam = import_zod20.z.object({ recruitId: RecruitIdSchema });
-var roomIdParam = import_zod20.z.object({ roomId: RoomIdSchema });
-var invitationIdParam = import_zod20.z.object({ invitationId: InvitationIdSchema });
-var notificationIdParam = import_zod20.z.object({ notificationId: import_zod20.z.string().min(1) });
-var planIdParam = import_zod20.z.object({ planId: PlanIdSchema });
-var couponIdParam = import_zod20.z.object({ couponId: CouponIdSchema });
-var friendRequestIdParam = import_zod20.z.object({ requestId: FriendRequestIdSchema });
+var memberIdParam = import_zod28.z.object({
+  memberId: MemberIdSchema
+});
+var articleIdParam = import_zod28.z.object({
+  articleId: ArticleIdSchema
+});
+var commentIdParam = import_zod28.z.object({
+  commentId: CommentIdSchema
+});
+var mealPlanIdParam = import_zod28.z.object({
+  mealPlanId: MealPlanIdSchema
+});
+var mealPlanInviteIdParam = import_zod28.z.object({
+  inviteId: MealPlanInviteIdSchema
+});
+var mealPlanJoinRequestIdParam = import_zod28.z.object({
+  requestId: MealPlanJoinRequestIdSchema
+});
+var mealPlanDecisionStageIdParam = mealPlanIdParam.extend({
+  stageId: MealPlanDecisionStageIdSchema
+});
+var mealPlanChangeRequestIdParam = mealPlanIdParam.extend({
+  requestId: MealPlanChangeRequestIdSchema
+});
+var mealPlanDecisionTaskKeyParam = mealPlanIdParam.extend({
+  taskKey: MealPlanDecisionTaskKeySchema
+});
+var mealPlanDecisionSnapshotIdParam = mealPlanIdParam.extend({
+  snapshotId: import_zod28.z.string().uuid()
+});
+var mealPlanParticipantIdParam = mealPlanIdParam.extend({
+  participantId: import_zod28.z.string().uuid()
+});
+var mealPlanShareTokenParam = import_zod28.z.object({
+  token: MealPlanShareLinkTokenSchema
+});
+var notificationIdParam = import_zod28.z.object({
+  notificationId: import_zod28.z.string().min(1)
+});
+var couponIdParam = import_zod28.z.object({
+  couponId: CouponIdSchema
+});
+var mealGroupIdParam = import_zod28.z.object({
+  mealGroupId: MealGroupIdSchema
+});
+var mealGroupMemberIdParam = mealGroupIdParam.extend({
+  memberId: MemberIdSchema
+});
+var friendRequestIdParam = import_zod28.z.object({
+  requestId: FriendRequestIdSchema
+});
+var sseTokenQuery = import_zod28.z.object({
+  token: import_zod28.z.string().min(1)
+});
 var apiContract = {
   auth: {
-    signup: endpoint({ method: "POST", path: "/auth/signup", body: SignupRequestSchema, response: SignupResponseSchema }),
-    login: endpoint({ method: "POST", path: "/auth/login", body: LoginRequestSchema, response: TokenResponseSchema }),
-    refresh: endpoint({ method: "POST", path: "/auth/refresh", response: TokenResponseSchema }),
-    logout: endpoint({ method: "POST", path: "/auth/logout", response: NoContentSchema })
-    // test: endpoint({method: "GET",  path: "/auth/test", response: TokenResponseSchema}) TODO: Dev에서만 작동하도록 백엔드에서 수정해야함
+    signup: endpoint({
+      method: "POST",
+      path: "/auth/signup",
+      body: SignupRequestSchema,
+      response: SignupResponseSchema
+    }),
+    login: endpoint({
+      method: "POST",
+      path: "/auth/login",
+      body: LoginRequestSchema,
+      response: TokenResponseSchema
+    }),
+    refresh: endpoint({
+      method: "POST",
+      path: "/auth/refresh",
+      response: TokenResponseSchema
+    }),
+    logout: endpoint({
+      method: "POST",
+      path: "/auth/logout",
+      response: NoContentSchema
+    })
   },
   members: {
-    me: endpoint({ method: "GET", path: "/members/me", response: MemberResponseSchema }),
-    myProfile: endpoint({ method: "GET", path: "/members/me/profile", response: ProfileDetailResponseSchema }),
-    search: endpoint({ method: "GET", path: "/members/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
-    memberProfile: endpoint({ method: "GET", path: "/members/:memberId/profile", pathParams: memberIdParam, response: ProfileDetailResponseSchema }),
-    presignProfileImage: endpoint({ method: "POST", path: "/uploads/presign-profile", body: UploadProfileImageRequestSchema, response: UploadProfileImageResponseSchema }),
-    createProfile: endpoint({ method: "POST", path: "/members/onboarding", body: CreateProfileRequestSchema, response: NoContentSchema }),
-    updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, response: NoContentSchema })
+    me: endpoint({
+      method: "GET",
+      path: "/members/me",
+      response: MemberResponseSchema
+    }),
+    myProfile: endpoint({
+      method: "GET",
+      path: "/members/me/profile",
+      response: ProfileDetailResponseSchema
+    }),
+    search: endpoint({
+      method: "GET",
+      path: "/members/search",
+      query: MemberSearchQuerySchema,
+      response: MemberSerachResponseSchema
+    }),
+    memberProfile: endpoint({
+      method: "GET",
+      path: "/members/:memberId/profile",
+      pathParams: memberIdParam,
+      response: ProfileDetailResponseSchema
+    }),
+    presignProfileImage: endpoint({
+      method: "POST",
+      path: "/uploads/presign-profile",
+      body: UploadProfileImageRequestSchema,
+      response: UploadProfileImageResponseSchema
+    }),
+    createProfile: endpoint({
+      method: "POST",
+      path: "/members/onboarding",
+      body: CreateProfileRequestSchema,
+      response: NoContentSchema
+    }),
+    createProfileAlias: endpoint({
+      method: "POST",
+      path: "/onboarding",
+      body: CreateProfileRequestSchema,
+      response: NoContentSchema
+    }),
+    updateProfile: endpoint({
+      method: "PATCH",
+      path: "/members/me/profile",
+      body: UpdateProfileRequestSchema,
+      response: NoContentSchema
+    }),
+    locationSettings: endpoint({
+      method: "GET",
+      path: "/members/me/location-settings",
+      response: MemberLocationSettingsResponseSchema
+    }),
+    updateLocationConsent: endpoint({
+      method: "PATCH",
+      path: "/members/me/location-consent",
+      body: UpdateMemberLocationConsentRequestSchema,
+      response: MemberLocationSettingsResponseSchema
+    }),
+    updateLocation: endpoint({
+      method: "PATCH",
+      path: "/members/me/location",
+      body: UpdateMemberLocationRequestSchema,
+      response: MemberLocationSettingsResponseSchema
+    })
   },
   preferences: {
-    my: endpoint({ method: "GET", path: "/preferences/me", response: MemberFoodPreferenceSchema }),
-    update: endpoint({ method: "PATCH", path: "/preferences/me", body: UpdatePreferenceRequestSchema, response: NoContentSchema })
+    my: endpoint({
+      method: "GET",
+      path: "/preferences/me",
+      response: MemberFoodPreferenceSchema
+    }),
+    update: endpoint({
+      method: "PATCH",
+      path: "/preferences/me",
+      body: UpdatePreferenceRequestSchema,
+      response: NoContentSchema
+    })
   },
   mealStatus: {
-    my: endpoint({ method: "GET", path: "/members/me/meal-status", response: MealStatusResponseSchema }),
-    updateMealStatus: endpoint({ method: "PATCH", path: "/members/me/meal-status", body: UpdateMealStatusRequestSchema, response: NoContentSchema }),
-    friendMealStatus: endpoint({ method: "GET", path: "/friends/me/meals", query: FriendMealQuerySchema, response: import_zod20.z.array(FriendMealItemResponseSchema) })
+    my: endpoint({
+      method: "GET",
+      path: "/members/me/meal-status",
+      response: MealStatusResponseSchema
+    }),
+    updateMealStatus: endpoint({
+      method: "PATCH",
+      path: "/members/me/meal-status",
+      body: UpdateMealStatusRequestSchema,
+      response: NoContentSchema
+    }),
+    friendMealStatus: endpoint({
+      method: "GET",
+      path: "/friends/me/meals",
+      query: FriendMealQuerySchema,
+      response: import_zod28.z.array(FriendMealItemResponseSchema)
+    })
   },
   articles: {
-    list: endpoint({ method: "GET", path: "/articles/home", query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
-    byMember: endpoint({ method: "GET", path: "/articles/by-author/:memberId", pathParams: memberIdParam, query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
-    my: endpoint({ method: "GET", path: "/articles/my", response: PageArticleSummaryResponseSchema }),
-    detail: endpoint({ method: "GET", path: "/articles/:articleId", pathParams: articleIdParam, response: ArticleDetailResponseSchema }),
-    create: endpoint({ method: "POST", path: "/articles", body: CreateArticleRequestSchema, response: CreatedEntityIdResponseSchema }),
-    like: endpoint({ method: "POST", path: "/articles/:articleId/like", pathParams: articleIdParam, response: ArticleLikeResponseSchema }),
-    createComment: endpoint({ method: "POST", path: "/articles/:articleId/comments", pathParams: articleIdParam, body: CreateCommentRequestSchema, response: CreatedEntityIdResponseSchema }),
-    presignArticleImage: endpoint({ method: "POST", path: "/uploads/presign-article", body: UploadArticleImageRequestSchema, response: UploadArticleImageResponseSchema }),
-    delete: endpoint({ method: "DELETE", path: "/articles/:articleId", pathParams: articleIdParam, response: NoContentSchema }),
-    deleteComment: endpoint({ method: "DELETE", path: "/articles/comments/:commentId", pathParams: commentIdParam, response: NoContentSchema })
-    // TODO: 게시물 수정 기능
-  },
-  recruits: {
-    list: endpoint({ method: "GET", path: "/recruits", query: RecruitListQuerySchema, response: RecruitListResponseSchema }),
-    create: endpoint({ method: "POST", path: "/recruits", body: CreateRecruitRequestSchema, response: CreateRecruitResponseSchema }),
-    join: endpoint({ method: "POST", path: "/recruits/:recruitId/join", pathParams: recruitIdParam, response: NoContentSchema }),
-    close: endpoint({ method: "POST", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema })
+    list: endpoint({
+      method: "GET",
+      path: "/articles/home",
+      query: ArticleListQuerySchema,
+      response: PageArticleSummaryResponseSchema
+    }),
+    byMember: endpoint({
+      method: "GET",
+      path: "/articles/by-author/:memberId",
+      pathParams: memberIdParam,
+      query: ArticleListQuerySchema,
+      response: PageArticleSummaryResponseSchema
+    }),
+    my: endpoint({
+      method: "GET",
+      path: "/articles/my",
+      response: PageArticleSummaryResponseSchema
+    }),
+    detail: endpoint({
+      method: "GET",
+      path: "/articles/:articleId",
+      pathParams: articleIdParam,
+      response: ArticleDetailResponseSchema
+    }),
+    create: endpoint({
+      method: "POST",
+      path: "/articles",
+      body: CreateArticleRequestSchema,
+      response: CreatedEntityIdResponseSchema
+    }),
+    like: endpoint({
+      method: "POST",
+      path: "/articles/:articleId/like",
+      pathParams: articleIdParam,
+      response: ArticleLikeResponseSchema
+    }),
+    createComment: endpoint({
+      method: "POST",
+      path: "/articles/:articleId/comments",
+      pathParams: articleIdParam,
+      body: CreateCommentRequestSchema,
+      response: CreatedEntityIdResponseSchema
+    }),
+    presignArticleImage: endpoint({
+      method: "POST",
+      path: "/uploads/presign-article",
+      body: UploadArticleImageRequestSchema,
+      response: UploadArticleImageResponseSchema
+    }),
+    delete: endpoint({
+      method: "DELETE",
+      path: "/articles/:articleId",
+      pathParams: articleIdParam,
+      response: NoContentSchema
+    }),
+    deleteComment: endpoint({
+      method: "DELETE",
+      path: "/articles/comments/:commentId",
+      pathParams: commentIdParam,
+      response: NoContentSchema
+    })
   },
-  invitations: {
-    list: endpoint({ method: "GET", path: "/invitations", response: import_zod20.z.array(InvitationListItemResponseSchema) }),
-    //  TODO: Invitation Response 정하기 detail: endpoint({ method: "GET", path: "/invitations/:invitationId", pathParams: invitationIdParam, response: InvitationItemDetailResponseSchema }),
-    send: endpoint({ method: "POST", path: "/invitations/send", body: CreateInvitationRequestSchema, response: SendInvitationResponseSchema }),
-    accept: endpoint({ method: "POST", path: "/invitations/:invitationId/accept", pathParams: invitationIdParam, response: AcceptInvitationResponseSchema }),
-    reject: endpoint({ method: "POST", path: "/invitations/:invitationId/reject", pathParams: invitationIdParam, response: NoContentSchema })
+  mealPlans: {
+    create: endpoint({
+      method: "POST",
+      path: "/meal-plans",
+      body: CreateMealPlanRequestSchema,
+      response: CreateMealPlanResponseSchema
+    }),
+    my: endpoint({
+      method: "GET",
+      path: "/meal-plans/me",
+      response: MyMealPlanListResponseSchema
+    }),
+    homeDashboard: endpoint({
+      method: "GET",
+      path: "/meal-plans/home-dashboard",
+      response: HomeMealPlanDashboardResponseSchema
+    }),
+    map: endpoint({
+      method: "GET",
+      path: "/meal-plans/map",
+      query: MealMapQuerySchema,
+      response: MealMapResponseSchema
+    }),
+    detail: endpoint({
+      method: "GET",
+      path: "/meal-plans/:mealPlanId",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    chatMessages: endpoint({
+      method: "GET",
+      path: "/meal-plans/:mealPlanId/chat/messages",
+      pathParams: mealPlanIdParam,
+      response: MealPlanChatMessageListResponseSchema
+    }),
+    updateContext: endpoint({
+      method: "PATCH",
+      path: "/meal-plans/:mealPlanId/context",
+      pathParams: mealPlanIdParam,
+      body: UpdateMealPlanContextRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    complete: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/complete",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    cancel: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/cancel",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    removeParticipant: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/participants/:participantId/remove",
+      pathParams: mealPlanParticipantIdParam,
+      response: MealPlanResponseSchema
+    }),
+    recorded: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/recorded",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    invite: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/invites",
+      pathParams: mealPlanIdParam,
+      body: CreateMealPlanInviteRequestSchema,
+      response: SendMealPlanInviteResponseSchema
+    }),
+    receivedInvites: endpoint({
+      method: "GET",
+      path: "/meal-plans/invites/received",
+      response: MealPlanInviteListResponseSchema
+    }),
+    sentInvites: endpoint({
+      method: "GET",
+      path: "/meal-plans/invites/sent",
+      response: MealPlanInviteListResponseSchema
+    }),
+    acceptInvite: endpoint({
+      method: "POST",
+      path: "/meal-plans/invites/:inviteId/accept",
+      pathParams: mealPlanInviteIdParam,
+      response: MealPlanResponseSchema
+    }),
+    declineInvite: endpoint({
+      method: "POST",
+      path: "/meal-plans/invites/:inviteId/decline",
+      pathParams: mealPlanInviteIdParam,
+      response: NoContentSchema
+    }),
+    createShareLink: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/share-links",
+      pathParams: mealPlanIdParam,
+      body: CreateMealPlanShareLinkRequestSchema,
+      response: MealPlanShareLinkSummarySchema
+    }),
+    sharePreview: endpoint({
+      method: "GET",
+      path: "/meal-plan-links/:token",
+      pathParams: mealPlanShareTokenParam,
+      response: MealPlanSharePreviewResponseSchema
+    }),
+    joinGuest: endpoint({
+      method: "POST",
+      path: "/meal-plan-links/:token/join",
+      pathParams: mealPlanShareTokenParam,
+      body: JoinMealPlanGuestRequestSchema,
+      response: JoinMealPlanGuestResponseSchema
+    }),
+    guestSession: endpoint({
+      method: "GET",
+      path: "/meal-plan-links/:token/session",
+      pathParams: mealPlanShareTokenParam,
+      query: MealPlanGuestSessionQuerySchema,
+      response: MealPlanGuestSessionResponseSchema
+    }),
+    guestChatMessages: endpoint({
+      method: "GET",
+      path: "/meal-plan-links/:token/chat/messages",
+      pathParams: mealPlanShareTokenParam,
+      query: MealPlanGuestSessionQuerySchema,
+      response: MealPlanChatMessageListResponseSchema
+    }),
+    exposeNearbyFriends: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/nearby-friends/expose",
+      pathParams: mealPlanIdParam,
+      body: ExposeMealPlanToNearbyFriendsRequestSchema,
+      response: ExposeMealPlanToNearbyFriendsResponseSchema
+    }),
+    closeNearbyFriends: endpoint({
+      method: "DELETE",
+      path: "/meal-plans/:mealPlanId/nearby-friends/expose",
+      pathParams: mealPlanIdParam,
+      response: NoContentSchema
+    }),
+    nearbyFriendExposureEligibility: endpoint({
+      method: "GET",
+      path: "/meal-plans/nearby-friends/eligibility",
+      response: NearbyFriendExposureEligibilitySchema
+    }),
+    nearbyFriends: endpoint({
+      method: "GET",
+      path: "/meal-plans/nearby-friends",
+      response: import_zod28.z.array(NearbyFriendMealPlanSummarySchema)
+    }),
+    requestJoin: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/join-requests",
+      pathParams: mealPlanIdParam,
+      body: CreateMealPlanJoinRequestSchema,
+      response: CreatedEntityIdResponseSchema
+    }),
+    acceptJoinRequest: endpoint({
+      method: "POST",
+      path: "/meal-plans/join-requests/:requestId/accept",
+      pathParams: mealPlanJoinRequestIdParam,
+      response: MealPlanResponseSchema
+    }),
+    rejectJoinRequest: endpoint({
+      method: "POST",
+      path: "/meal-plans/join-requests/:requestId/reject",
+      pathParams: mealPlanJoinRequestIdParam,
+      response: NoContentSchema
+    }),
+    vote: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/stages/:stageId/votes",
+      pathParams: mealPlanDecisionStageIdParam,
+      body: CreateMealPlanVoteRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    completeStage: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/stages/:stageId/complete",
+      pathParams: mealPlanDecisionStageIdParam,
+      body: CompleteMealPlanDecisionStageRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    decisionProgress: endpoint({
+      method: "GET",
+      path: "/meal-plans/:mealPlanId/decision-progress",
+      pathParams: mealPlanIdParam,
+      response: MealPlanDecisionProgressSchema
+    }),
+    readyDecisionTask: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/decision-tasks/:taskKey/ready",
+      pathParams: mealPlanDecisionTaskKeyParam,
+      body: MealPlanDecisionTaskReadyRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    reopenDecisionTask: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/decision-tasks/:taskKey/reopen",
+      pathParams: mealPlanDecisionTaskKeyParam,
+      body: ReopenMealPlanDecisionTaskRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    confirmDecisionSnapshot: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/decision-snapshots/:snapshotId/confirm",
+      pathParams: mealPlanDecisionSnapshotIdParam,
+      body: ConfirmMealPlanDecisionSnapshotRequestSchema,
+      response: MealPlanResponseSchema
+    }),
+    ready: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/ready",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    unready: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/unready",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    }),
+    createChangeRequest: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/change-requests",
+      pathParams: mealPlanIdParam,
+      body: CreateMealPlanChangeRequestSchema,
+      response: CreatedEntityIdResponseSchema
+    }),
+    acceptChangeRequest: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/change-requests/:requestId/accept",
+      pathParams: mealPlanChangeRequestIdParam,
+      response: MealPlanResponseSchema
+    }),
+    confirm: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/confirm",
+      pathParams: mealPlanIdParam,
+      response: MealPlanResponseSchema
+    })
   },
-  plans: {
-    list: endpoint({ method: "GET", path: "/plans", query: PlanListQuerySchema, response: import_zod20.z.array(PlanResponseSchema) }),
-    detail: endpoint({ method: "GET", path: "/plans/:planId", pathParams: planIdParam, response: PlanResponseSchema }),
-    cancel: endpoint({ method: "PATCH", path: "/plans/:planId/cancel", pathParams: planIdParam, response: NoContentSchema })
+  mealGroups: {
+    create: endpoint({
+      method: "POST",
+      path: "/meal-groups",
+      body: CreateMealGroupRequestSchema,
+      response: MealGroupResponseSchema
+    }),
+    list: endpoint({
+      method: "GET",
+      path: "/meal-groups",
+      response: import_zod28.z.array(MealGroupResponseSchema)
+    }),
+    detail: endpoint({
+      method: "GET",
+      path: "/meal-groups/:mealGroupId",
+      pathParams: mealGroupIdParam,
+      response: MealGroupResponseSchema
+    }),
+    startMealPlan: endpoint({
+      method: "POST",
+      path: "/meal-groups/:mealGroupId/meal-plans",
+      pathParams: mealGroupIdParam,
+      body: StartMealPlanFromGroupRequestSchema,
+      response: CreateMealPlanResponseSchema
+    }),
+    history: endpoint({
+      method: "GET",
+      path: "/meal-groups/:mealGroupId/history",
+      pathParams: mealGroupIdParam,
+      response: MealGroupHistoryResponseSchema
+    }),
+    preferences: endpoint({
+      method: "GET",
+      path: "/meal-groups/:mealGroupId/preferences",
+      pathParams: mealGroupIdParam,
+      response: MealGroupPreferenceSummarySchema
+    }),
+    addMember: endpoint({
+      method: "POST",
+      path: "/meal-groups/:mealGroupId/members",
+      pathParams: mealGroupIdParam,
+      body: AddMealGroupMemberRequestSchema,
+      response: MealGroupResponseSchema
+    }),
+    updateMemberRole: endpoint({
+      method: "PATCH",
+      path: "/meal-groups/:mealGroupId/members/:memberId/role",
+      pathParams: mealGroupMemberIdParam,
+      body: UpdateMealGroupMemberRoleRequestSchema,
+      response: MealGroupResponseSchema
+    }),
+    removeMember: endpoint({
+      method: "DELETE",
+      path: "/meal-groups/:mealGroupId/members/:memberId",
+      pathParams: mealGroupMemberIdParam,
+      response: MealGroupResponseSchema
+    })
   },
   friends: {
-    list: endpoint({ method: "GET", path: "/friends", response: import_zod20.z.array(FriendListItemResponseSchema) }),
-    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod20.z.array(FriendBlockItemResponseSchema) }),
-    search: endpoint({ method: "GET", path: "/friends/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
-    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
-    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
-    sendRequest: endpoint({ method: "POST", path: "/friends/requests/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
-    acceptRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/accept", pathParams: friendRequestIdParam, response: NoContentSchema }),
-    rejectRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/reject", pathParams: friendRequestIdParam, response: NoContentSchema }),
-    block: endpoint({ method: "POST", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
-    cancelRequest: endpoint({ method: "DELETE", path: "/friends/requests/:requestId", pathParams: friendRequestIdParam, response: NoContentSchema }),
-    unblock: endpoint({ method: "DELETE", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
-    unfriend: endpoint({ method: "DELETE", path: "/friends/:memberId", pathParams: memberIdParam, response: NoContentSchema })
+    list: endpoint({
+      method: "GET",
+      path: "/friends",
+      response: import_zod28.z.array(FriendListItemResponseSchema)
+    }),
+    blockList: endpoint({
+      method: "GET",
+      path: "/friends/blocks",
+      response: import_zod28.z.array(FriendBlockItemResponseSchema)
+    }),
+    search: endpoint({
+      method: "GET",
+      path: "/friends/search",
+      query: MemberSearchQuerySchema,
+      response: MemberSerachResponseSchema
+    }),
+    incomingRequest: endpoint({
+      method: "GET",
+      path: "/friends/requests/incoming",
+      response: import_zod28.z.array(FriendRequestItemResponseSchema)
+    }),
+    outgoingRequest: endpoint({
+      method: "GET",
+      path: "/friends/requests/outgoing",
+      response: import_zod28.z.array(FriendRequestItemResponseSchema)
+    }),
+    sendRequest: endpoint({
+      method: "POST",
+      path: "/friends/requests/:memberId",
+      pathParams: memberIdParam,
+      response: NoContentSchema
+    }),
+    acceptRequest: endpoint({
+      method: "POST",
+      path: "/friends/requests/:requestId/accept",
+      pathParams: friendRequestIdParam,
+      response: NoContentSchema
+    }),
+    rejectRequest: endpoint({
+      method: "POST",
+      path: "/friends/requests/:requestId/reject",
+      pathParams: friendRequestIdParam,
+      response: NoContentSchema
+    }),
+    block: endpoint({
+      method: "POST",
+      path: "/friends/blocks/:memberId",
+      pathParams: memberIdParam,
+      response: NoContentSchema
+    }),
+    cancelRequest: endpoint({
+      method: "DELETE",
+      path: "/friends/requests/:requestId",
+      pathParams: friendRequestIdParam,
+      response: NoContentSchema
+    }),
+    unblock: endpoint({
+      method: "DELETE",
+      path: "/friends/blocks/:memberId",
+      pathParams: memberIdParam,
+      response: NoContentSchema
+    }),
+    unfriend: endpoint({
+      method: "DELETE",
+      path: "/friends/:memberId",
+      pathParams: memberIdParam,
+      response: NoContentSchema
+    })
   },
   coupons: {
-    list: endpoint({ method: "GET", path: "/coupons", response: import_zod20.z.array(CouponResponseSchema) }),
-    use: endpoint({ method: "POST", path: "/coupons/:couponId/use", pathParams: couponIdParam, response: NoContentSchema })
+    list: endpoint({
+      method: "GET",
+      path: "/coupons",
+      response: import_zod28.z.array(CouponResponseSchema)
+    }),
+    use: endpoint({
+      method: "POST",
+      path: "/coupons/:couponId/use",
+      pathParams: couponIdParam,
+      response: NoContentSchema
+    })
   },
   challenges: {
-    status: endpoint({ method: "GET", path: "/challenges/status", response: ChallengeStatusResponseSchema }),
-    claimReward: endpoint({ method: "POST", path: "/challenges/rewards", body: ClaimChallengeRewardRequestSchema, response: NoContentSchema })
+    status: endpoint({
+      method: "GET",
+      path: "/challenges/status",
+      response: ChallengeStatusResponseSchema
+    }),
+    claimReward: endpoint({
+      method: "POST",
+      path: "/challenges/rewards",
+      body: ClaimChallengeRewardRequestSchema,
+      response: NoContentSchema
+    })
   },
   referrals: {
-    list: endpoint({ method: "GET", path: "/referrals", response: import_zod20.z.array(ReferralItemResponseSchema) }),
-    create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
-    redeem: endpoint({ method: "POST", path: "/referrals/redeem", body: RedeemReferralRequestSchema, response: NoContentSchema })
+    list: endpoint({
+      method: "GET",
+      path: "/referrals",
+      response: import_zod28.z.array(ReferralItemResponseSchema)
+    }),
+    create: endpoint({
+      method: "POST",
+      path: "/referrals",
+      response: ReferralCreateResponseSchema
+    }),
+    redeem: endpoint({
+      method: "POST",
+      path: "/referrals/redeem",
+      body: RedeemReferralRequestSchema,
+      response: NoContentSchema
+    })
   },
   notifications: {
-    list: endpoint({ method: "GET", path: "/notifications", response: import_zod20.z.array(MatchingNotificationSchema) }),
-    markRead: endpoint({ method: "PATCH", path: "/notifications/:notificationId/read", pathParams: notificationIdParam, response: MatchingNotificationSchema }),
-    delete: endpoint({ method: "DELETE", path: "/notifications/:notificationId", pathParams: notificationIdParam, response: NoContentSchema })
+    list: endpoint({
+      method: "GET",
+      path: "/notifications",
+      response: import_zod28.z.array(MealPlanNotificationSchema)
+    }),
+    markRead: endpoint({
+      method: "PATCH",
+      path: "/notifications/:notificationId/read",
+      pathParams: notificationIdParam,
+      response: MealPlanNotificationSchema
+    }),
+    delete: endpoint({
+      method: "DELETE",
+      path: "/notifications/:notificationId",
+      pathParams: notificationIdParam,
+      response: NoContentSchema
+    })
   },
-  room: {
-    access: endpoint({ method: "GET", path: "/rooms/:roomId/access", pathParams: roomIdParam, response: RoomAccessResponseSchema })
+  pushTokens: {
+    list: endpoint({
+      method: "GET",
+      path: "/push-tokens",
+      response: import_zod28.z.array(PushTokenResponseSchema)
+    }),
+    register: endpoint({
+      method: "POST",
+      path: "/push-tokens",
+      body: RegisterPushTokenRequestSchema,
+      response: PushTokenResponseSchema
+    }),
+    revoke: endpoint({
+      method: "POST",
+      path: "/push-tokens/revoke",
+      body: RevokePushTokenRequestSchema,
+      response: NoContentSchema
+    })
+  },
+  liveActivities: {
+    listMealPlanSessions: endpoint({
+      method: "GET",
+      path: "/meal-plans/:mealPlanId/live-activity",
+      pathParams: mealPlanIdParam,
+      response: MealPlanLiveActivitySessionListResponseSchema
+    }),
+    registerMealPlanSession: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/live-activity/sessions",
+      pathParams: mealPlanIdParam,
+      body: RegisterMealPlanLiveActivitySessionRequestSchema,
+      response: MealPlanLiveActivitySessionResponseSchema
+    }),
+    endMealPlanSessions: endpoint({
+      method: "POST",
+      path: "/meal-plans/:mealPlanId/live-activity/end",
+      pathParams: mealPlanIdParam,
+      body: EndMealPlanLiveActivitySessionRequestSchema,
+      response: NoContentSchema
+    })
+  },
+  sse: {
+    notifications: endpoint({
+      method: "GET",
+      path: "/sse/notifications",
+      query: sseTokenQuery,
+      response: import_zod28.z.any()
+    })
   },
   health: {
-    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod20.z.string() })
+    healthCheck: endpoint({
+      method: "GET",
+      path: "/",
+      response: import_zod28.z.string()
+    })
   }
 };
 
+// src/domain/common/contracts/cache-invalidation.ts
+var CACHE_INVALIDATION_SSE_EVENT = "cache-invalidate";
+
 // src/domain/common/contracts/envelope.ts
 var makeApiResponseSchema = ApiResponseSchema;
 var makeApiSuccessSchema = ApiSuccessSchema;
 
 // src/domain/common/contracts/id.ts
-var toMemberId = (value) => MemberIdSchema.parse(value);
-var toArticleId = (value) => ArticleIdSchema.parse(value);
-var toRecruitId = (value) => RecruitIdSchema.parse(value);
-var toInvitationId = (value) => InvitationIdSchema.parse(value);
-var toRoomId = (value) => RoomIdSchema.parse(value);
-var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
-var toCommentId = (value) => CommentIdSchema.parse(value);
-var toPlanId = (value) => PlanIdSchema.parse(value);
-var toCouponId = (value) => CouponIdSchema.parse(value);
-var toSubscriptionId = (value) => SubscriptionIdSchema.parse(value);
-var toFriendRequestId = (value) => FriendRequestIdSchema.parse(value);
-var toReferralCode = (value) => ReferralCodeSchema.parse(value);
+var toMemberId = /* @__PURE__ */ __name((value) => MemberIdSchema.parse(value), "toMemberId");
+var toArticleId = /* @__PURE__ */ __name((value) => ArticleIdSchema.parse(value), "toArticleId");
+var toMealPlanId = /* @__PURE__ */ __name((value) => MealPlanIdSchema.parse(value), "toMealPlanId");
+var toMealPlanInviteId = /* @__PURE__ */ __name((value) => MealPlanInviteIdSchema.parse(value), "toMealPlanInviteId");
+var toMealPlanJoinRequestId = /* @__PURE__ */ __name((value) => MealPlanJoinRequestIdSchema.parse(value), "toMealPlanJoinRequestId");
+var toMealPlanNearbyFriendExposureBatchId = /* @__PURE__ */ __name((value) => MealPlanNearbyFriendExposureBatchIdSchema.parse(value), "toMealPlanNearbyFriendExposureBatchId");
+var toMealPlanChangeRequestId = /* @__PURE__ */ __name((value) => MealPlanChangeRequestIdSchema.parse(value), "toMealPlanChangeRequestId");
+var toMealPlanShareLinkId = /* @__PURE__ */ __name((value) => MealPlanShareLinkIdSchema.parse(value), "toMealPlanShareLinkId");
+var toMealPlanShareLinkToken = /* @__PURE__ */ __name((value) => MealPlanShareLinkTokenSchema.parse(value), "toMealPlanShareLinkToken");
+var toMealPlanChatRoomId = /* @__PURE__ */ __name((value) => MealPlanChatRoomIdSchema.parse(value), "toMealPlanChatRoomId");
+var toMealPlanChatMessageId = /* @__PURE__ */ __name((value) => MealPlanChatMessageIdSchema.parse(value), "toMealPlanChatMessageId");
+var toMealGroupId = /* @__PURE__ */ __name((value) => MealGroupIdSchema.parse(value), "toMealGroupId");
+var toRestaurantId = /* @__PURE__ */ __name((value) => RestaurantIdSchema.parse(value), "toRestaurantId");
+var toCommentId = /* @__PURE__ */ __name((value) => CommentIdSchema.parse(value), "toCommentId");
+var toCouponId = /* @__PURE__ */ __name((value) => CouponIdSchema.parse(value), "toCouponId");
+var toSubscriptionId = /* @__PURE__ */ __name((value) => SubscriptionIdSchema.parse(value), "toSubscriptionId");
+var toFriendRequestId = /* @__PURE__ */ __name((value) => FriendRequestIdSchema.parse(value), "toFriendRequestId");
+var toReferralCode = /* @__PURE__ */ __name((value) => ReferralCodeSchema.parse(value), "toReferralCode");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiFailureSchema,
   ApiResponseSchema,
   ApiSuccessSchema,
   ArticleIdSchema,
+  CACHE_INVALIDATION_SSE_EVENT,
+  CacheInvalidationActionSchema,
+  CacheInvalidationEntitySchema,
+  CacheInvalidationEventSchema,
+  CacheInvalidationKeySchema,
   CommentIdSchema,
   CouponIdSchema,
   CreatedEntityIdResponseSchema,
@@ -804,7 +2497,16 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   FriendRequestIdSchema,
   ISODateStringSchema,
   ISODateTimeStringSchema,
-  InvitationIdSchema,
+  MealGroupIdSchema,
+  MealPlanChangeRequestIdSchema,
+  MealPlanChatMessageIdSchema,
+  MealPlanChatRoomIdSchema,
+  MealPlanIdSchema,
+  MealPlanInviteIdSchema,
+  MealPlanJoinRequestIdSchema,
+  MealPlanNearbyFriendExposureBatchIdSchema,
+  MealPlanShareLinkIdSchema,
+  MealPlanShareLinkTokenSchema,
   MemberIdSchema,
   NoBodySchema,
   NoContentSchema,
@@ -814,12 +2516,9 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   PageMetaSchema,
   PageQuerySchema,
   PageResponseSchema,
-  PlanIdSchema,
   PositiveIntIdSchema,
-  RecruitIdSchema,
   ReferralCodeSchema,
   RestaurantIdSchema,
-  RoomIdSchema,
   SortDirectionSchema,
   SubscriptionIdSchema,
   TimeHHmmStringSchema,
@@ -832,12 +2531,18 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   toCommentId,
   toCouponId,
   toFriendRequestId,
-  toInvitationId,
+  toMealGroupId,
+  toMealPlanChangeRequestId,
+  toMealPlanChatMessageId,
+  toMealPlanChatRoomId,
+  toMealPlanId,
+  toMealPlanInviteId,
+  toMealPlanJoinRequestId,
+  toMealPlanNearbyFriendExposureBatchId,
+  toMealPlanShareLinkId,
+  toMealPlanShareLinkToken,
   toMemberId,
-  toPlanId,
-  toRecruitId,
   toReferralCode,
   toRestaurantId,
-  toRoomId,
   toSubscriptionId
 });