@kimdaegyu/babmukdang-shared 1.1.10 → 2.0.2

package/dist/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 });
@@ -30,11 +31,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  InvitationStageMap: () => InvitationStageMap,
-  MenuRecommendationAIResponseDto: () => MenuRecommendationAIResponseDto,
-  RecruitStageMap: () => RecruitStageMap,
-  RoomSocketClientEventSchemas: () => RoomSocketClientEventSchemas,
-  RoomSocketServerEventSchemas: () => RoomSocketServerEventSchemas,
   domain: () => domain_exports
 });
 module.exports = __toCommonJS(index_exports);
@@ -42,8 +38,10 @@ module.exports = __toCommonJS(index_exports);
 // src/domain/index.ts
 var domain_exports = {};
 __export(domain_exports, {
-  AcceptInvitationResponseSchema: () => AcceptInvitationResponseSchema,
-  AddLocationCandidateRequestSchema: () => AddLocationCandidateRequestSchema,
+  AI_CLASS_TO_FOOD_CODE_MAP_PATH: () => AI_CLASS_TO_FOOD_CODE_MAP_PATH,
+  AddMealGroupMemberRequestSchema: () => AddMealGroupMemberRequestSchema,
+  AiClassFoodCodeMappingSchema: () => AiClassFoodCodeMappingSchema,
+  AiClassToFoodCodeMapManifestSchema: () => AiClassToFoodCodeMapManifestSchema,
   ApiFailureSchema: () => ApiFailureSchema,
   ApiResponseSchema: () => ApiResponseSchema,
   ApiSuccessSchema: () => ApiSuccessSchema,
@@ -55,33 +53,61 @@ __export(domain_exports, {
   ArticleListQuerySchema: () => ArticleListQuerySchema,
   ArticleSortBySchema: () => ArticleSortBySchema,
   ArticleSummaryResponseSchema: () => ArticleSummaryResponseSchema,
+  CACHE_INVALIDATION_SSE_EVENT: () => CACHE_INVALIDATION_SSE_EVENT,
+  CacheInvalidationActionSchema: () => CacheInvalidationActionSchema,
+  CacheInvalidationEntitySchema: () => CacheInvalidationEntitySchema,
+  CacheInvalidationEventSchema: () => CacheInvalidationEventSchema,
+  CacheInvalidationKeySchema: () => CacheInvalidationKeySchema,
   ChallengeStatusResponseSchema: () => ChallengeStatusResponseSchema,
-  ChatMessageRequestSchema: () => ChatMessageRequestSchema,
-  ChatMessageResponseSchema: () => ChatMessageResponseSchema,
   ClaimChallengeRewardRequestSchema: () => ClaimChallengeRewardRequestSchema,
   ClaimChallengeRewardResponseSchema: () => ClaimChallengeRewardResponseSchema,
   CommentIdSchema: () => CommentIdSchema,
+  CompleteMealPlanDecisionStageRequestSchema: () => CompleteMealPlanDecisionStageRequestSchema,
+  CompleteOnboardingRequestSchema: () => CompleteOnboardingRequestSchema,
+  ConfirmMealPlanDecisionSnapshotRequestSchema: () => ConfirmMealPlanDecisionSnapshotRequestSchema,
   CouponIdSchema: () => CouponIdSchema,
   CouponResponseSchema: () => CouponResponseSchema,
   CouponStatusSchema: () => CouponStatusSchema,
   CouponTypeSchema: () => CouponTypeSchema,
   CreateArticleRequestSchema: () => CreateArticleRequestSchema,
   CreateCommentRequestSchema: () => CreateCommentRequestSchema,
-  CreateInvitationRequestSchema: () => CreateInvitationRequestSchema,
+  CreateMealGroupRequestSchema: () => CreateMealGroupRequestSchema,
+  CreateMealPlanChangeRequestSchema: () => CreateMealPlanChangeRequestSchema,
+  CreateMealPlanInviteRequestSchema: () => CreateMealPlanInviteRequestSchema,
+  CreateMealPlanJoinRequestSchema: () => CreateMealPlanJoinRequestSchema,
+  CreateMealPlanParticipantRequestSchema: () => CreateMealPlanParticipantRequestSchema,
+  CreateMealPlanRequestSchema: () => CreateMealPlanRequestSchema,
+  CreateMealPlanResponseSchema: () => CreateMealPlanResponseSchema,
+  CreateMealPlanShareLinkRequestSchema: () => CreateMealPlanShareLinkRequestSchema,
+  CreateMealPlanVoteRequestSchema: () => CreateMealPlanVoteRequestSchema,
   CreateProfileRequestSchema: () => CreateProfileRequestSchema,
-  CreateRecruitRequestSchema: () => CreateRecruitRequestSchema,
-  CreateRecruitResponseSchema: () => CreateRecruitResponseSchema,
   CreatedEntityIdResponseSchema: () => CreatedEntityIdResponseSchema,
-  DatePicksUpdateResponseSchema: () => DatePicksUpdateResponseSchema,
-  ExcludeMenuRequestSchema: () => ExcludeMenuRequestSchema,
-  ExcludeMenuUpdateResponseSchema: () => ExcludeMenuUpdateResponseSchema,
-  FinalStateSchema: () => FinalStateSchema,
+  CuisineTagSchema: () => CuisineTagSchema,
+  DevicePermissionSnapshotSchema: () => DevicePermissionSnapshotSchema,
+  EndMealPlanLiveActivitySessionRequestSchema: () => EndMealPlanLiveActivitySessionRequestSchema,
+  ExposeMealPlanToNearbyFriendsRequestSchema: () => ExposeMealPlanToNearbyFriendsRequestSchema,
+  ExposeMealPlanToNearbyFriendsResponseSchema: () => ExposeMealPlanToNearbyFriendsResponseSchema,
+  FOOD_CODE_MANIFEST_PATH: () => FOOD_CODE_MANIFEST_PATH,
+  FOOD_IMAGE_INDEX_PATH: () => FOOD_IMAGE_INDEX_PATH,
+  FoodAiClassMappingStatusSchema: () => FoodAiClassMappingStatusSchema,
   FoodAnalysisResultSchema: () => FoodAnalysisResultSchema,
+  FoodCodeManifestImageSchema: () => FoodCodeManifestImageSchema,
+  FoodCodeManifestItemSchema: () => FoodCodeManifestItemSchema,
+  FoodCodeManifestSchema: () => FoodCodeManifestSchema,
   FoodCodeSchema: () => FoodCodeSchema,
+  FoodGranularitySchema: () => FoodGranularitySchema,
+  FoodImageIndexItemSchema: () => FoodImageIndexItemSchema,
+  FoodImageIndexManifestSchema: () => FoodImageIndexManifestSchema,
   FoodLabelSchema: () => FoodLabelSchema,
+  FoodResolveQuerySchema: () => FoodResolveQuerySchema,
+  FoodResolveResponseSchema: () => FoodResolveResponseSchema,
+  FoodResolvedMatchSourceSchema: () => FoodResolvedMatchSourceSchema,
   FoodSchema: () => FoodSchema,
+  FoodSearchQuerySchema: () => FoodSearchQuerySchema,
+  FoodSearchResponseSchema: () => FoodSearchResponseSchema,
   FriendBlockItemResponseSchema: () => FriendBlockItemResponseSchema,
   FriendListItemResponseSchema: () => FriendListItemResponseSchema,
+  FriendMealAvailabilitySchema: () => FriendMealAvailabilitySchema,
   FriendMealItemResponseSchema: () => FriendMealItemResponseSchema,
   FriendMealQuerySchema: () => FriendMealQuerySchema,
   FriendRequestIdSchema: () => FriendRequestIdSchema,
@@ -90,19 +116,121 @@ __export(domain_exports, {
   FriendRequestStatusSchema: () => FriendRequestStatusSchema,
   FriendSearchQuerySchema: () => FriendSearchQuerySchema,
   FriendSearchResponseSchema: () => FriendSearchResponseSchema,
+  HomeMealPlanActionCardSchema: () => HomeMealPlanActionCardSchema,
+  HomeMealPlanActionKindSchema: () => HomeMealPlanActionKindSchema,
+  HomeMealPlanDashboardResponseSchema: () => HomeMealPlanDashboardResponseSchema,
   ISODateStringSchema: () => ISODateStringSchema,
   ISODateTimeStringSchema: () => ISODateTimeStringSchema,
-  InvitationIdSchema: () => InvitationIdSchema,
-  InvitationListItemResponseSchema: () => InvitationListItemResponseSchema,
-  InvitationRoomStageSchema: () => InvitationRoomStageSchema,
+  JoinMealPlanGuestRequestSchema: () => JoinMealPlanGuestRequestSchema,
+  JoinMealPlanGuestResponseSchema: () => JoinMealPlanGuestResponseSchema,
   KakaoPlaceRawSchema: () => KakaoPlaceRawSchema,
-  LocationCandidateAddUpdateResponseSchema: () => LocationCandidateAddUpdateResponseSchema,
-  LocationCandidateSchema: () => LocationCandidateSchema,
-  LocationCandidateVoteUpdateResponseSchema: () => LocationCandidateVoteUpdateResponseSchema,
-  LocationIdSchema: () => LocationIdSchema,
+  LocationConsentStatusSchema: () => LocationConsentStatusSchema,
   LoginRequestSchema: () => LoginRequestSchema,
-  MatchingNotificationKindSchema: () => MatchingNotificationKindSchema,
-  MatchingNotificationSchema: () => MatchingNotificationSchema,
+  MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES: () => MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES,
+  MealGroupHistoryItemSchema: () => MealGroupHistoryItemSchema,
+  MealGroupHistoryResponseSchema: () => MealGroupHistoryResponseSchema,
+  MealGroupIdSchema: () => MealGroupIdSchema,
+  MealGroupMemberRoleSchema: () => MealGroupMemberRoleSchema,
+  MealGroupMemberSchema: () => MealGroupMemberSchema,
+  MealGroupPreferenceSummarySchema: () => MealGroupPreferenceSummarySchema,
+  MealGroupResponseSchema: () => MealGroupResponseSchema,
+  MealMapFriendRecordLocationMetadataSchema: () => MealMapFriendRecordLocationMetadataSchema,
+  MealMapLayerSchema: () => MealMapLayerSchema,
+  MealMapMarkerSchema: () => MealMapMarkerSchema,
+  MealMapMyMealPlanPlaceMetadataSchema: () => MealMapMyMealPlanPlaceMetadataSchema,
+  MealMapNearbyFriendMealPlanMetadataSchema: () => MealMapNearbyFriendMealPlanMetadataSchema,
+  MealMapQuerySchema: () => MealMapQuerySchema,
+  MealMapResponseSchema: () => MealMapResponseSchema,
+  MealMapRestaurantCandidateCompletionBlockedReasonSchema: () => MealMapRestaurantCandidateCompletionBlockedReasonSchema,
+  MealMapRestaurantCandidateMetadataSchema: () => MealMapRestaurantCandidateMetadataSchema,
+  MealPlanChangeRequestIdSchema: () => MealPlanChangeRequestIdSchema,
+  MealPlanChangeRequestStatusSchema: () => MealPlanChangeRequestStatusSchema,
+  MealPlanChangeRequestSummarySchema: () => MealPlanChangeRequestSummarySchema,
+  MealPlanChannelSchema: () => MealPlanChannelSchema,
+  MealPlanChatMessageIdSchema: () => MealPlanChatMessageIdSchema,
+  MealPlanChatMessageKindSchema: () => MealPlanChatMessageKindSchema,
+  MealPlanChatMessageListResponseSchema: () => MealPlanChatMessageListResponseSchema,
+  MealPlanChatMessageResponseSchema: () => MealPlanChatMessageResponseSchema,
+  MealPlanChatRoomIdSchema: () => MealPlanChatRoomIdSchema,
+  MealPlanChatRoomSummarySchema: () => MealPlanChatRoomSummarySchema,
+  MealPlanChatSystemPayloadSchema: () => MealPlanChatSystemPayloadSchema,
+  MealPlanDecisionActorTypeSchema: () => MealPlanDecisionActorTypeSchema,
+  MealPlanDecisionCandidateSchema: () => MealPlanDecisionCandidateSchema,
+  MealPlanDecisionFinalFieldSchema: () => MealPlanDecisionFinalFieldSchema,
+  MealPlanDecisionProgressSchema: () => MealPlanDecisionProgressSchema,
+  MealPlanDecisionReasonSchema: () => MealPlanDecisionReasonSchema,
+  MealPlanDecisionSnapshotSchema: () => MealPlanDecisionSnapshotSchema,
+  MealPlanDecisionSnapshotStatusSchema: () => MealPlanDecisionSnapshotStatusSchema,
+  MealPlanDecisionStageIdSchema: () => MealPlanDecisionStageIdSchema,
+  MealPlanDecisionStageMetadataSchema: () => MealPlanDecisionStageMetadataSchema,
+  MealPlanDecisionStageResponseSchema: () => MealPlanDecisionStageResponseSchema,
+  MealPlanDecisionStageStatusSchema: () => MealPlanDecisionStageStatusSchema,
+  MealPlanDecisionStageTypeSchema: () => MealPlanDecisionStageTypeSchema,
+  MealPlanDecisionTaskKeySchema: () => MealPlanDecisionTaskKeySchema,
+  MealPlanDecisionTaskProgressSchema: () => MealPlanDecisionTaskProgressSchema,
+  MealPlanDecisionTaskReadyRequestSchema: () => MealPlanDecisionTaskReadyRequestSchema,
+  MealPlanDecisionTaskStatusSchema: () => MealPlanDecisionTaskStatusSchema,
+  MealPlanGuestParticipantSchema: () => MealPlanGuestParticipantSchema,
+  MealPlanGuestSessionQuerySchema: () => MealPlanGuestSessionQuerySchema,
+  MealPlanGuestSessionResponseSchema: () => MealPlanGuestSessionResponseSchema,
+  MealPlanIdSchema: () => MealPlanIdSchema,
+  MealPlanInviteIdSchema: () => MealPlanInviteIdSchema,
+  MealPlanInviteListResponseSchema: () => MealPlanInviteListResponseSchema,
+  MealPlanInviteStatusSchema: () => MealPlanInviteStatusSchema,
+  MealPlanInviteSummarySchema: () => MealPlanInviteSummarySchema,
+  MealPlanJoinRequestIdSchema: () => MealPlanJoinRequestIdSchema,
+  MealPlanJoinRequestStatusSchema: () => MealPlanJoinRequestStatusSchema,
+  MealPlanJoinRequestSummarySchema: () => MealPlanJoinRequestSummarySchema,
+  MealPlanJoinSourceSchema: () => MealPlanJoinSourceSchema,
+  MealPlanLatitudeSchema: () => MealPlanLatitudeSchema,
+  MealPlanLiveActivityBehaviorSchema: () => MealPlanLiveActivityBehaviorSchema,
+  MealPlanLiveActivityPlatformSchema: () => MealPlanLiveActivityPlatformSchema,
+  MealPlanLiveActivitySessionListResponseSchema: () => MealPlanLiveActivitySessionListResponseSchema,
+  MealPlanLiveActivitySessionResponseSchema: () => MealPlanLiveActivitySessionResponseSchema,
+  MealPlanLiveActivitySessionStatusSchema: () => MealPlanLiveActivitySessionStatusSchema,
+  MealPlanLiveActivityStateSchema: () => MealPlanLiveActivityStateSchema,
+  MealPlanLiveActivityUpdateStatusSchema: () => MealPlanLiveActivityUpdateStatusSchema,
+  MealPlanLocationCandidateIdSchema: () => MealPlanLocationCandidateIdSchema,
+  MealPlanLocationCandidateSchema: () => MealPlanLocationCandidateSchema,
+  MealPlanLocationCandidateSourceSchema: () => MealPlanLocationCandidateSourceSchema,
+  MealPlanLongitudeSchema: () => MealPlanLongitudeSchema,
+  MealPlanMenuCandidateIdSchema: () => MealPlanMenuCandidateIdSchema,
+  MealPlanMenuCandidateSchema: () => MealPlanMenuCandidateSchema,
+  MealPlanMenuCandidateSourceSchema: () => MealPlanMenuCandidateSourceSchema,
+  MealPlanNearbyFriendExposureBatchIdSchema: () => MealPlanNearbyFriendExposureBatchIdSchema,
+  MealPlanNearbyFriendExposureBatchSummarySchema: () => MealPlanNearbyFriendExposureBatchSummarySchema,
+  MealPlanNearbyFriendExposureIdSchema: () => MealPlanNearbyFriendExposureIdSchema,
+  MealPlanNearbyFriendExposureNotificationStatusSchema: () => MealPlanNearbyFriendExposureNotificationStatusSchema,
+  MealPlanNearbyFriendExposureStatusSchema: () => MealPlanNearbyFriendExposureStatusSchema,
+  MealPlanNearbyFriendExposureSummarySchema: () => MealPlanNearbyFriendExposureSummarySchema,
+  MealPlanNearbyFriendRejectionReasonSchema: () => MealPlanNearbyFriendRejectionReasonSchema,
+  MealPlanNearbyFriendRejectionSummarySchema: () => MealPlanNearbyFriendRejectionSummarySchema,
+  MealPlanNotificationKindSchema: () => MealPlanNotificationKindSchema,
+  MealPlanNotificationPriorityChannelSchema: () => MealPlanNotificationPriorityChannelSchema,
+  MealPlanNotificationPriorityPolicyItemSchema: () => MealPlanNotificationPriorityPolicyItemSchema,
+  MealPlanNotificationSchema: () => MealPlanNotificationSchema,
+  MealPlanParticipantIdSchema: () => MealPlanParticipantIdSchema,
+  MealPlanParticipantResponseSchema: () => MealPlanParticipantResponseSchema,
+  MealPlanParticipantRoleSchema: () => MealPlanParticipantRoleSchema,
+  MealPlanParticipantStatusSchema: () => MealPlanParticipantStatusSchema,
+  MealPlanPushPayloadDataSchema: () => MealPlanPushPayloadDataSchema,
+  MealPlanRecommendationContextSchema: () => MealPlanRecommendationContextSchema,
+  MealPlanResponseSchema: () => MealPlanResponseSchema,
+  MealPlanRestaurantCandidateSchema: () => MealPlanRestaurantCandidateSchema,
+  MealPlanRestaurantSearchStateSchema: () => MealPlanRestaurantSearchStateSchema,
+  MealPlanRestaurantSearchStatusSchema: () => MealPlanRestaurantSearchStatusSchema,
+  MealPlanShareLinkIdSchema: () => MealPlanShareLinkIdSchema,
+  MealPlanShareLinkSummarySchema: () => MealPlanShareLinkSummarySchema,
+  MealPlanShareLinkTokenSchema: () => MealPlanShareLinkTokenSchema,
+  MealPlanSharePreviewResponseSchema: () => MealPlanSharePreviewResponseSchema,
+  MealPlanStatusSchema: () => MealPlanStatusSchema,
+  MealPlanSystemMessageKindSchema: () => MealPlanSystemMessageKindSchema,
+  MealPlanSystemMessageSchema: () => MealPlanSystemMessageSchema,
+  MealPlanViewerPermissionsSchema: () => MealPlanViewerPermissionsSchema,
+  MealPlanViewerRoleSchema: () => MealPlanViewerRoleSchema,
+  MealPlanVoteIdSchema: () => MealPlanVoteIdSchema,
+  MealPlanVoteSchema: () => MealPlanVoteSchema,
+  MealPlanVoteTypeSchema: () => MealPlanVoteTypeSchema,
   MealStatusActionSchema: () => MealStatusActionSchema,
   MealStatusResponseSchema: () => MealStatusResponseSchema,
   MealStatusSchema: () => MealStatusSchema,
@@ -110,67 +238,68 @@ __export(domain_exports, {
   MemberDetailSchema: () => MemberDetailSchema,
   MemberFoodPreferenceSchema: () => MemberFoodPreferenceSchema,
   MemberIdSchema: () => MemberIdSchema,
+  MemberLocationSchema: () => MemberLocationSchema,
+  MemberLocationSettingsResponseSchema: () => MemberLocationSettingsResponseSchema,
   MemberResponseSchema: () => MemberResponseSchema,
   MemberRoleSchema: () => MemberRoleSchema,
   MemberSearchQuerySchema: () => MemberSearchQuerySchema,
   MemberSerachResponseSchema: () => MemberSerachResponseSchema,
-  MenuCodeSchema: () => MenuCodeSchema,
-  MenuPickUpdateResponseSchema: () => MenuPickUpdateResponseSchema,
-  MenuSchema: () => MenuSchema,
+  MyMealPlanGroupSchema: () => MyMealPlanGroupSchema,
+  MyMealPlanListItemSchema: () => MyMealPlanListItemSchema,
+  MyMealPlanListResponseSchema: () => MyMealPlanListResponseSchema,
+  NearbyFriendExposureEligibilitySchema: () => NearbyFriendExposureEligibilitySchema,
+  NearbyFriendMealPlanSummarySchema: () => NearbyFriendMealPlanSummarySchema,
   NoBodySchema: () => NoBodySchema,
   NoContentSchema: () => NoContentSchema,
   NoParamsSchema: () => NoParamsSchema,
   NoQuerySchema: () => NoQuerySchema,
   NonEmptyStringIdSchema: () => NonEmptyStringIdSchema,
+  OnboardingDraftSchema: () => OnboardingDraftSchema,
+  OnboardingStatusSchema: () => OnboardingStatusSchema,
   PageArticleSummaryResponseSchema: () => PageArticleSummaryResponseSchema,
   PageMetaSchema: () => PageMetaSchema,
   PageQuerySchema: () => PageQuerySchema,
   PageResponseSchema: () => PageResponseSchema,
-  ParticipantSchema: () => ParticipantSchema,
-  PhaseDataBroadcastSchema: () => PhaseDataBroadcastSchema,
-  PickDateRequestSchema: () => PickDateRequestSchema,
-  PickMenuRequestSchema: () => PickMenuRequestSchema,
-  PickRestaurantRequestSchema: () => PickRestaurantRequestSchema,
-  PickTimesRequestSchema: () => PickTimesRequestSchema,
-  PlanIdSchema: () => PlanIdSchema,
-  PlanListQuerySchema: () => PlanListQuerySchema,
-  PlanResponseSchema: () => PlanResponseSchema,
-  PlanStatusSchema: () => PlanStatusSchema,
-  PlanTypeSchema: () => PlanTypeSchema,
+  PermissionKindSchema: () => PermissionKindSchema,
+  PermissionPlatformSchema: () => PermissionPlatformSchema,
+  PermissionStatusSchema: () => PermissionStatusSchema,
   PositiveIntIdSchema: () => PositiveIntIdSchema,
   ProfileDetailResponseSchema: () => ProfileDetailResponseSchema,
-  ReadyStateChangedSchema: () => ReadyStateChangedSchema,
-  ReadyStateRequestSchema: () => ReadyStateRequestSchema,
-  RecruitIdSchema: () => RecruitIdSchema,
-  RecruitListQuerySchema: () => RecruitListQuerySchema,
-  RecruitListResponseSchema: () => RecruitListResponseSchema,
-  RecruitRoomStageSchema: () => RecruitRoomStageSchema,
-  RecruitSortBySchema: () => RecruitSortBySchema,
-  RecruitStatusSchema: () => RecruitStatusSchema,
+  PushDeliveryAttemptResultSchema: () => PushDeliveryAttemptResultSchema,
+  PushDeliveryAttemptSummarySchema: () => PushDeliveryAttemptSummarySchema,
+  PushDeliveryOutboxSummarySchema: () => PushDeliveryOutboxSummarySchema,
+  PushDeliveryStatusSchema: () => PushDeliveryStatusSchema,
+  PushPayloadSchemaVersionSchema: () => PushPayloadSchemaVersionSchema,
+  PushPermissionStatusSchema: () => PushPermissionStatusSchema,
+  PushPlatformSchema: () => PushPlatformSchema,
+  PushProviderSchema: () => PushProviderSchema,
+  PushTokenResponseSchema: () => PushTokenResponseSchema,
+  PushTokenStatusSchema: () => PushTokenStatusSchema,
   RedeemReferralRequestSchema: () => RedeemReferralRequestSchema,
   ReferralCodeSchema: () => ReferralCodeSchema,
   ReferralCreateResponseSchema: () => ReferralCreateResponseSchema,
   ReferralItemResponseSchema: () => ReferralItemResponseSchema,
+  RegisterMealPlanLiveActivitySessionRequestSchema: () => RegisterMealPlanLiveActivitySessionRequestSchema,
+  RegisterPushTokenRequestSchema: () => RegisterPushTokenRequestSchema,
+  ReopenMealPlanDecisionTaskRequestSchema: () => ReopenMealPlanDecisionTaskRequestSchema,
+  ResolvedFoodCodeSchema: () => ResolvedFoodCodeSchema,
   RestaurantIdSchema: () => RestaurantIdSchema,
-  RestaurantPickUpdateResponseSchema: () => RestaurantPickUpdateResponseSchema,
   RestaurantSchema: () => RestaurantSchema,
-  RoomAccessResponseSchema: () => RoomAccessResponseSchema,
-  RoomAssignedResponseSchema: () => RoomAssignedResponseSchema,
-  RoomIdSchema: () => RoomIdSchema,
-  RoomInitialStateSchema: () => RoomInitialStateSchema,
-  RoomSocketClientEventSchemas: () => RoomSocketClientEventSchemas,
-  RoomSocketErrorSchema: () => RoomSocketErrorSchema,
-  RoomSocketServerEventSchemas: () => RoomSocketServerEventSchemas,
-  RoomTypeSchema: () => RoomTypeSchema,
-  SendInvitationResponseSchema: () => SendInvitationResponseSchema,
+  RevokePushTokenRequestSchema: () => RevokePushTokenRequestSchema,
+  SendMealPlanChatMessageRequestSchema: () => SendMealPlanChatMessageRequestSchema,
+  SendMealPlanInviteResponseSchema: () => SendMealPlanInviteResponseSchema,
   SignupRequestSchema: () => SignupRequestSchema,
   SignupResponseSchema: () => SignupResponseSchema,
   SortDirectionSchema: () => SortDirectionSchema,
+  StartMealPlanFromGroupRequestSchema: () => StartMealPlanFromGroupRequestSchema,
   SubscriptionIdSchema: () => SubscriptionIdSchema,
   TimeHHmmStringSchema: () => TimeHHmmStringSchema,
-  TimePicksUpdateResponseSchema: () => TimePicksUpdateResponseSchema,
   TokenResponseSchema: () => TokenResponseSchema,
+  UpdateMealGroupMemberRoleRequestSchema: () => UpdateMealGroupMemberRoleRequestSchema,
+  UpdateMealPlanContextRequestSchema: () => UpdateMealPlanContextRequestSchema,
   UpdateMealStatusRequestSchema: () => UpdateMealStatusRequestSchema,
+  UpdateMemberLocationConsentRequestSchema: () => UpdateMemberLocationConsentRequestSchema,
+  UpdateMemberLocationRequestSchema: () => UpdateMemberLocationRequestSchema,
   UpdatePreferenceRequestSchema: () => UpdatePreferenceRequestSchema,
   UpdateProfileRequestSchema: () => UpdateProfileRequestSchema,
   UploadArticleImageRequestSchema: () => UploadArticleImageRequestSchema,
@@ -178,22 +307,32 @@ __export(domain_exports, {
   UploadProfileImageRequestSchema: () => UploadProfileImageRequestSchema,
   UploadProfileImageResponseSchema: () => UploadProfileImageResponseSchema,
   UserIdSchema: () => UserIdSchema,
-  VoteLocationRequestSchema: () => VoteLocationRequestSchema,
   apiContract: () => apiContract,
+  compareMealPlanNotificationsByPriority: () => compareMealPlanNotificationsByPriority,
   endpoint: () => endpoint,
+  getMealPlanLiveActivityBehavior: () => getMealPlanLiveActivityBehavior,
+  getMealPlanNotificationPriority: () => getMealPlanNotificationPriority,
+  getMealPlanNotificationPriorityPolicy: () => getMealPlanNotificationPriorityPolicy,
   makeApiResponseSchema: () => makeApiResponseSchema,
   makeApiSuccessSchema: () => makeApiSuccessSchema,
+  shouldShowForegroundToast: () => shouldShowForegroundToast,
   toArticleId: () => toArticleId,
   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
 });
 
@@ -204,7 +343,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
@@ -215,10 +357,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();
@@ -245,11 +393,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");
@@ -266,7 +417,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),
@@ -278,6 +488,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(),
@@ -288,7 +503,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({
@@ -303,9 +522,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");
@@ -337,7 +563,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")
@@ -353,7 +583,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),
@@ -373,6 +604,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,
@@ -412,65 +644,145 @@ var SignupResponseSchema = import_zod8.z.object({
 });
 
 // src/domain/common/contracts/api.ts
-var import_zod20 = require("zod");
+var import_zod28 = require("zod");
 
-// 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
@@ -486,626 +798,2207 @@ 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 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 RoomTypeSchema = import_zod14.z.enum(["recruit", "invitation"]);
-var InvitationRoomStageSchema = import_zod14.z.enum([
-  "waiting",
+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 AddLocationCandidateRequestSchema = LocationCandidateSchema;
-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 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()
 });
-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 })
-]);
-var RoomSocketClientEventSchemas = {
-  "ready-state": ReadyStateRequestSchema,
-  "chat-message": ChatMessageRequestSchema,
-  "add-location-candidate": AddLocationCandidateRequestSchema,
-  "vote-location": VoteLocationRequestSchema,
-  "exclude-menu": ExcludeMenuRequestSchema,
-  "pick-menu": PickMenuRequestSchema,
-  "pick-restaurant": PickRestaurantRequestSchema,
-  "pick-times": PickTimesRequestSchema,
-  "pick-date": PickDateRequestSchema
-};
-var RoomSocketServerEventSchemas = {
-  "room-assigned": RoomAssignedResponseSchema,
-  "stage-changed": PhaseDataBroadcastSchema,
-  "chat-message": ChatMessageResponseSchema,
-  "room-error": RoomSocketErrorSchema,
-  "ready-state-changed": ReadyStateChangedSchema,
-  "join-room": RoomInitialStateSchema,
-  "time-updated": TimePicksUpdateResponseSchema,
-  "date-updated": DatePicksUpdateResponseSchema,
-  "location-add-updated": LocationCandidateAddUpdateResponseSchema,
-  "location-vote-updated": LocationCandidateVoteUpdateResponseSchema,
-  "exclude-menu-updated": ExcludeMenuUpdateResponseSchema,
-  "menu-pick-updated": MenuPickUpdateResponseSchema,
-  "restaurant-pick-updated": RestaurantPickUpdateResponseSchema,
-  "final-state-response": FinalStateSchema
-};
 
-// 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,
+// 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 MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES = {
+  MEAL_PLAN_JOIN_REQUESTED: {
+    kind: "MEAL_PLAN_JOIN_REQUESTED",
+    priority: 5,
+    homePriority: 5,
+    inboxPriority: 5,
+    fcmPriority: 10,
+    liveActivityPriority: 80,
+    liveActivityBehavior: "NONE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_INVITE_RECEIVED: {
+    kind: "MEAL_PLAN_INVITE_RECEIVED",
+    priority: 12,
+    homePriority: 12,
+    inboxPriority: 12,
+    fcmPriority: 15,
+    liveActivityPriority: 80,
+    liveActivityBehavior: "NONE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_RECORD_NEEDED: {
+    kind: "MEAL_PLAN_RECORD_NEEDED",
+    priority: 18,
+    homePriority: 18,
+    inboxPriority: 18,
+    fcmPriority: 20,
+    liveActivityPriority: 60,
+    liveActivityBehavior: "END",
+    foregroundToast: true
+  },
+  MEAL_PLAN_LOCKED: {
+    kind: "MEAL_PLAN_LOCKED",
+    priority: 22,
+    homePriority: 22,
+    inboxPriority: 22,
+    fcmPriority: 8,
+    liveActivityPriority: 5,
+    liveActivityBehavior: "START_OR_UPDATE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_CONFIRMED: {
+    kind: "MEAL_PLAN_CONFIRMED",
+    priority: 24,
+    homePriority: 24,
+    inboxPriority: 24,
+    fcmPriority: 12,
+    liveActivityPriority: 12,
+    liveActivityBehavior: "START_OR_UPDATE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_NEARBY_FRIEND_EXPOSED: {
+    kind: "MEAL_PLAN_NEARBY_FRIEND_EXPOSED",
+    priority: 28,
+    homePriority: 28,
+    inboxPriority: 28,
+    fcmPriority: 24,
+    liveActivityPriority: 80,
+    liveActivityBehavior: "NONE",
+    foregroundToast: false
+  },
+  MEAL_PLAN_READY_COMPLETED: {
+    kind: "MEAL_PLAN_READY_COMPLETED",
+    priority: 32,
+    homePriority: 32,
+    inboxPriority: 32,
+    fcmPriority: 28,
+    liveActivityPriority: 20,
+    liveActivityBehavior: "UPDATE",
+    foregroundToast: false
+  },
+  MEAL_PLAN_JOIN_REQUEST_ACCEPTED: {
+    kind: "MEAL_PLAN_JOIN_REQUEST_ACCEPTED",
+    priority: 36,
+    homePriority: 36,
+    inboxPriority: 36,
+    fcmPriority: 30,
+    liveActivityPriority: 80,
+    liveActivityBehavior: "NONE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_INVITE_ACCEPTED: {
+    kind: "MEAL_PLAN_INVITE_ACCEPTED",
+    priority: 40,
+    homePriority: 40,
+    inboxPriority: 40,
+    fcmPriority: 34,
+    liveActivityPriority: 80,
+    liveActivityBehavior: "NONE",
+    foregroundToast: true
+  },
+  MEAL_PLAN_PARTICIPANT_JOINED: {
+    kind: "MEAL_PLAN_PARTICIPANT_JOINED",
+    priority: 44,
+    homePriority: 44,
+    inboxPriority: 44,
+    fcmPriority: 38,
+    liveActivityPriority: 32,
+    liveActivityBehavior: "UPDATE",
+    foregroundToast: false
+  }
+};
+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/meal-plan/meal-plan-notification-priority.ts
+var DEFAULT_POLICY = MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES.MEAL_PLAN_PARTICIPANT_JOINED;
+function getMealPlanNotificationPriorityPolicy(kind) {
+  return MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES[kind] ?? DEFAULT_POLICY;
+}
+__name(getMealPlanNotificationPriorityPolicy, "getMealPlanNotificationPriorityPolicy");
+function getMealPlanNotificationPriority(kind, channel = "HOME") {
+  const policy = getMealPlanNotificationPriorityPolicy(kind);
+  switch (channel) {
+    case "HOME":
+      return policy.homePriority;
+    case "NOTIFICATION_INBOX":
+      return policy.inboxPriority;
+    case "FCM_PUSH":
+      return policy.fcmPriority;
+    case "LIVE_ACTIVITY":
+      return policy.liveActivityPriority;
+    default:
+      return policy.priority;
+  }
+}
+__name(getMealPlanNotificationPriority, "getMealPlanNotificationPriority");
+function getMealPlanLiveActivityBehavior(kind) {
+  return getMealPlanNotificationPriorityPolicy(kind).liveActivityBehavior;
+}
+__name(getMealPlanLiveActivityBehavior, "getMealPlanLiveActivityBehavior");
+function shouldShowForegroundToast(kind) {
+  return getMealPlanNotificationPriorityPolicy(kind).foregroundToast;
+}
+__name(shouldShowForegroundToast, "shouldShowForegroundToast");
+function compareMealPlanNotificationsByPriority(channel) {
+  return (a, b) => {
+    const unreadDelta = Number(Boolean(a.readAt)) - Number(Boolean(b.readAt));
+    if (unreadDelta !== 0) return unreadDelta;
+    const priorityDelta = getMealPlanNotificationPriority(a.kind, channel) - getMealPlanNotificationPriority(b.kind, channel);
+    if (priorityDelta !== 0) return priorityDelta;
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  };
+}
+__name(compareMealPlanNotificationsByPriority, "compareMealPlanNotificationsByPriority");
+
 // 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");
 
-// src/types/matching/types.ts
-var RecruitStageMap = {
-  waiting: 1,
-  location: 2,
-  "location-vote": 3,
-  "exclude-menu": 4,
-  menu: 5,
-  restaurant: 6,
-  finish: 7
-};
-var InvitationStageMap = {
-  waiting: 1,
-  date: 2,
-  time: 3,
-  location: 4,
-  "location-vote": 5,
-  "exclude-menu": 6,
-  menu: 7,
-  restaurant: 8,
-  finish: 9
-};
+// src/domain/food/food.contracts.ts
+var FOOD_CODE_MANIFEST_PATH = "/manifests/food-code-manifest.json";
+var AI_CLASS_TO_FOOD_CODE_MAP_PATH = "/manifests/ai-class-to-food-code-map.json";
+var FOOD_IMAGE_INDEX_PATH = "/manifests/food-image-index.json";
 
-// src/types/ai/menu-ai.ts
-var MenuRecommendationAIResponseDto = {
-  group_id: null,
-  user_ids: ["user_a", "user_b", "user_c"],
-  exclude_days: 3,
-  per_user: [
-    {
-      user_id: "user_a",
-      excluded_codes: [],
-      overrides_applied: [],
-      taste_top: [
-        {
-          code: "02011027",
-          label: "\uC790\uC7A5\uBA74",
-          score: 0.5784
-        },
-        {
-          code: "11015001",
-          label: "\uC7A1\uCC44",
-          score: 0.3671
-        },
-        {
-          code: "03021005",
-          label: "\uBD88\uACE0\uAE30",
-          score: 0.3451
-        },
-        {
-          code: "05011001",
-          label: "\uBE44\uBE54\uBC25",
-          score: 0.3212
-        }
-      ]
-    },
-    {
-      user_id: "user_b",
-      excluded_codes: [],
-      overrides_applied: [],
-      taste_top: [
-        {
-          code: "05011001",
-          label: "\uBE44\uBE54\uBC25",
-          score: 0.4793
-        },
-        {
-          code: "11015001",
-          label: "\uC7A1\uCC44",
-          score: 0.4052
-        },
-        {
-          code: "03021005",
-          label: "\uBD88\uACE0\uAE30",
-          score: 0.3189
-        },
-        {
-          code: "02011027",
-          label: "\uC790\uC7A5\uBA74",
-          score: 0.3103
-        }
-      ]
-    },
-    {
-      user_id: "user_c",
-      excluded_codes: [],
-      overrides_applied: [],
-      taste_top: [
-        {
-          code: "02011027",
-          label: "\uC790\uC7A5\uBA74",
-          score: 0.6998
-        },
-        {
-          code: "11015001",
-          label: "\uC7A1\uCC44",
-          score: 0.4993
-        },
-        {
-          code: "05011001",
-          label: "\uBE44\uBE54\uBC25",
-          score: 0.4701
-        },
-        {
-          code: "03021005",
-          label: "\uBD88\uACE0\uAE30",
-          score: 0.3383
-        }
-      ]
-    }
-  ],
-  group_excluded: {
-    mode: "union",
-    codes: []
-  },
-  recommendations: [
-    {
-      code: "02011027",
-      label: "\uC790\uC7A5\uBA74",
-      group_score: 0.5295,
-      member_scores: {
-        user_a: 0.5784,
-        user_b: 0.3103,
-        user_c: 0.6998
-      },
-      reasons: ["\uC911\uAC04 \uCDE8\uD5A5", "\uCD5C\uADFC 3\uC77C \uB0B4 \uBBF8\uC12D\uCDE8"]
-    },
-    {
-      code: "11015001",
-      label: "\uC7A1\uCC44",
-      group_score: 0.4239,
-      member_scores: {
-        user_a: 0.3671,
-        user_b: 0.4052,
-        user_c: 0.4993
-      },
-      reasons: ["\uC911\uAC04 \uCDE8\uD5A5", "\uCD5C\uADFC 3\uC77C \uB0B4 \uBBF8\uC12D\uCDE8"]
-    },
-    {
-      code: "05011001",
-      label: "\uBE44\uBE54\uBC25",
-      group_score: 0.4235,
-      member_scores: {
-        user_a: 0.3212,
-        user_b: 0.4793,
-        user_c: 0.4701
-      },
-      reasons: ["\uC911\uAC04 \uCDE8\uD5A5", "\uCD5C\uADFC 3\uC77C \uB0B4 \uBBF8\uC12D\uCDE8"]
-    },
-    {
-      code: "03021005",
-      label: "\uBD88\uACE0\uAE30",
-      group_score: 0.3341,
-      member_scores: {
-        user_a: 0.3451,
-        user_b: 0.3189,
-        user_c: 0.3383
-      },
-      reasons: ["\uC911\uAC04 \uCDE8\uD5A5", "\uCD5C\uADFC 3\uC77C \uB0B4 \uBBF8\uC12D\uCDE8"]
-    }
-  ],
-  params: {
-    taste_mode: "mean",
-    exclude_mode: "union",
-    weights: {},
-    top_k: 10
-  }
-};
+// src/domain/food/food.schema.ts
+var import_zod29 = require("zod");
+var FoodGranularitySchema = import_zod29.z.enum([
+  "main_dish",
+  "side_dish",
+  "beverage",
+  "sauce"
+]);
+var CuisineTagSchema = import_zod29.z.enum([
+  "korean",
+  "western",
+  "chinese",
+  "japanese",
+  "mexican",
+  "indian",
+  "asian",
+  "snack",
+  "dessert",
+  "beverage",
+  "unknown"
+]);
+var FoodResolvedMatchSourceSchema = import_zod29.z.enum([
+  "category",
+  "alias",
+  "lexical",
+  "semantic"
+]);
+var FoodCodeManifestImageSchema = import_zod29.z.object({
+  src: import_zod29.z.string().min(1),
+  avifSrcset: import_zod29.z.string().min(1).optional(),
+  thumbhashDataURL: import_zod29.z.string().min(1).optional(),
+  aspectRatio: import_zod29.z.number().positive().optional()
+});
+var FoodCodeManifestItemSchema = import_zod29.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  aliases: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
+  parentCategory: import_zod29.z.string().min(1),
+  cuisineTags: import_zod29.z.array(CuisineTagSchema).default([]),
+  categoryTags: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
+  semanticTags: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
+  granularity: FoodGranularitySchema,
+  searchable: import_zod29.z.boolean(),
+  recommendable: import_zod29.z.boolean(),
+  previewEnabled: import_zod29.z.boolean(),
+  imageUrl: import_zod29.z.string().min(1).nullable().optional(),
+  image: FoodCodeManifestImageSchema.nullable().optional(),
+  popularity: import_zod29.z.number().nonnegative().optional(),
+  source: import_zod29.z.enum([
+    "foodname",
+    "manual",
+    "foodai",
+    "legacy"
+  ]).optional()
+});
+var FoodCodeManifestSchema = import_zod29.z.object({
+  version: import_zod29.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod29.z.string().min(1),
+  etag: import_zod29.z.string().min(1).optional(),
+  items: import_zod29.z.array(FoodCodeManifestItemSchema),
+  categoryIndex: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.array(FoodCodeSchema)),
+  aliasIndex: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.array(FoodCodeSchema)).optional()
+});
+var FoodImageIndexItemSchema = import_zod29.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  imageUrl: import_zod29.z.string().min(1).nullable(),
+  image: FoodCodeManifestImageSchema.nullable(),
+  source: import_zod29.z.enum([
+    "foodname",
+    "manual",
+    "foodai",
+    "legacy"
+  ]).optional()
+});
+var FoodImageIndexManifestSchema = import_zod29.z.object({
+  version: import_zod29.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod29.z.string().min(1),
+  items: import_zod29.z.array(FoodImageIndexItemSchema)
+});
+var ResolvedFoodCodeSchema = import_zod29.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  matchedBy: FoodResolvedMatchSourceSchema,
+  score: import_zod29.z.number(),
+  granularity: FoodGranularitySchema,
+  imageUrl: import_zod29.z.string().min(1).nullable().optional()
+});
+var BooleanQuerySchema = import_zod29.z.preprocess((value) => {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}, import_zod29.z.boolean());
+var FoodResolveQuerySchema = import_zod29.z.object({
+  q: import_zod29.z.string().default(""),
+  limit: import_zod29.z.coerce.number().int().min(1).max(100).optional().default(30),
+  recommendableOnly: BooleanQuerySchema.optional().default(true)
+});
+var FoodSearchQuerySchema = import_zod29.z.object({
+  q: import_zod29.z.string().default(""),
+  limit: import_zod29.z.coerce.number().int().min(1).max(100).optional().default(20)
+});
+var FoodResolveResponseSchema = import_zod29.z.object({
+  query: import_zod29.z.string(),
+  items: import_zod29.z.array(ResolvedFoodCodeSchema)
+});
+var FoodSearchResponseSchema = FoodResolveResponseSchema;
+var FoodAiClassMappingStatusSchema = import_zod29.z.enum([
+  "exact",
+  "broad",
+  "narrow",
+  "merged",
+  "ignored",
+  "review_required"
+]);
+var AiClassFoodCodeMappingSchema = import_zod29.z.object({
+  classId: import_zod29.z.number().int().nonnegative(),
+  aiLabel: import_zod29.z.string().min(1),
+  aiAliases: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
+  representativeCode: FoodCodeSchema.nullable(),
+  candidateCodes: import_zod29.z.array(FoodCodeSchema).default([]),
+  mappingStatus: FoodAiClassMappingStatusSchema,
+  granularity: FoodGranularitySchema,
+  searchable: import_zod29.z.boolean(),
+  recommendable: import_zod29.z.boolean(),
+  reason: import_zod29.z.string().min(1).optional()
+});
+var AiClassToFoodCodeMapManifestSchema = import_zod29.z.object({
+  version: import_zod29.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  modelTaxonomyVersion: import_zod29.z.string().min(1),
+  serviceTaxonomyVersion: import_zod29.z.string().min(1),
+  classes: import_zod29.z.array(AiClassFoodCodeMappingSchema)
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  InvitationStageMap,
-  MenuRecommendationAIResponseDto,
-  RecruitStageMap,
-  RoomSocketClientEventSchemas,
-  RoomSocketServerEventSchemas,
   domain
 });