@kimdaegyu/babmukdang-shared 1.1.11 → 2.0.3

package/dist/domain/meal-plan/index.cjs

@@ -0,0 +1,1540 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/domain/meal-plan/index.ts
+var meal_plan_exports = {};
+__export(meal_plan_exports, {
+  AddMealGroupMemberRequestSchema: () => AddMealGroupMemberRequestSchema,
+  CompleteMealPlanDecisionStageRequestSchema: () => CompleteMealPlanDecisionStageRequestSchema,
+  ConfirmMealPlanDecisionSnapshotRequestSchema: () => ConfirmMealPlanDecisionSnapshotRequestSchema,
+  CreateMealGroupRequestSchema: () => CreateMealGroupRequestSchema,
+  CreateMealPlanChangeRequestSchema: () => CreateMealPlanChangeRequestSchema,
+  CreateMealPlanInviteRequestSchema: () => CreateMealPlanInviteRequestSchema,
+  CreateMealPlanJoinRequestSchema: () => CreateMealPlanJoinRequestSchema,
+  CreateMealPlanParticipantRequestSchema: () => CreateMealPlanParticipantRequestSchema,
+  CreateMealPlanRequestSchema: () => CreateMealPlanRequestSchema,
+  CreateMealPlanResponseSchema: () => CreateMealPlanResponseSchema,
+  CreateMealPlanShareLinkRequestSchema: () => CreateMealPlanShareLinkRequestSchema,
+  CreateMealPlanVoteRequestSchema: () => CreateMealPlanVoteRequestSchema,
+  ExposeMealPlanToNearbyFriendsRequestSchema: () => ExposeMealPlanToNearbyFriendsRequestSchema,
+  ExposeMealPlanToNearbyFriendsResponseSchema: () => ExposeMealPlanToNearbyFriendsResponseSchema,
+  HomeMealPlanActionCardSchema: () => HomeMealPlanActionCardSchema,
+  HomeMealPlanActionKindSchema: () => HomeMealPlanActionKindSchema,
+  HomeMealPlanDashboardResponseSchema: () => HomeMealPlanDashboardResponseSchema,
+  JoinMealPlanGuestRequestSchema: () => JoinMealPlanGuestRequestSchema,
+  JoinMealPlanGuestResponseSchema: () => JoinMealPlanGuestResponseSchema,
+  MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES: () => MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES,
+  MealGroupHistoryItemSchema: () => MealGroupHistoryItemSchema,
+  MealGroupHistoryResponseSchema: () => MealGroupHistoryResponseSchema,
+  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,
+  MealPlanChangeRequestStatusSchema: () => MealPlanChangeRequestStatusSchema,
+  MealPlanChangeRequestSummarySchema: () => MealPlanChangeRequestSummarySchema,
+  MealPlanChannelSchema: () => MealPlanChannelSchema,
+  MealPlanChatMessageKindSchema: () => MealPlanChatMessageKindSchema,
+  MealPlanChatMessageListResponseSchema: () => MealPlanChatMessageListResponseSchema,
+  MealPlanChatMessageResponseSchema: () => MealPlanChatMessageResponseSchema,
+  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,
+  MealPlanDecisionTaskStatusSchema: () => MealPlanDecisionTaskStatusSchema,
+  MealPlanGuestParticipantSchema: () => MealPlanGuestParticipantSchema,
+  MealPlanGuestSessionQuerySchema: () => MealPlanGuestSessionQuerySchema,
+  MealPlanGuestSessionResponseSchema: () => MealPlanGuestSessionResponseSchema,
+  MealPlanInviteListResponseSchema: () => MealPlanInviteListResponseSchema,
+  MealPlanInviteStatusSchema: () => MealPlanInviteStatusSchema,
+  MealPlanInviteSummarySchema: () => MealPlanInviteSummarySchema,
+  MealPlanJoinRequestStatusSchema: () => MealPlanJoinRequestStatusSchema,
+  MealPlanJoinRequestSummarySchema: () => MealPlanJoinRequestSummarySchema,
+  MealPlanJoinSourceSchema: () => MealPlanJoinSourceSchema,
+  MealPlanLatitudeSchema: () => MealPlanLatitudeSchema,
+  MealPlanLiveActivityBehaviorSchema: () => MealPlanLiveActivityBehaviorSchema,
+  MealPlanLocationCandidateIdSchema: () => MealPlanLocationCandidateIdSchema,
+  MealPlanLocationCandidateSchema: () => MealPlanLocationCandidateSchema,
+  MealPlanLocationCandidateSourceSchema: () => MealPlanLocationCandidateSourceSchema,
+  MealPlanLongitudeSchema: () => MealPlanLongitudeSchema,
+  MealPlanMenuCandidateIdSchema: () => MealPlanMenuCandidateIdSchema,
+  MealPlanMenuCandidateSchema: () => MealPlanMenuCandidateSchema,
+  MealPlanMenuCandidateSourceSchema: () => MealPlanMenuCandidateSourceSchema,
+  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,
+  MealPlanRecommendationContextSchema: () => MealPlanRecommendationContextSchema,
+  MealPlanResponseSchema: () => MealPlanResponseSchema,
+  MealPlanRestaurantCandidateSchema: () => MealPlanRestaurantCandidateSchema,
+  MealPlanRestaurantSearchStateSchema: () => MealPlanRestaurantSearchStateSchema,
+  MealPlanRestaurantSearchStatusSchema: () => MealPlanRestaurantSearchStatusSchema,
+  MealPlanShareLinkSummarySchema: () => MealPlanShareLinkSummarySchema,
+  MealPlanSharePreviewResponseSchema: () => MealPlanSharePreviewResponseSchema,
+  MealPlanStatusSchema: () => MealPlanStatusSchema,
+  MealPlanSystemMessageKindSchema: () => MealPlanSystemMessageKindSchema,
+  MealPlanSystemMessageSchema: () => MealPlanSystemMessageSchema,
+  MealPlanViewerPermissionsSchema: () => MealPlanViewerPermissionsSchema,
+  MealPlanViewerRoleSchema: () => MealPlanViewerRoleSchema,
+  MealPlanVoteIdSchema: () => MealPlanVoteIdSchema,
+  MealPlanVoteSchema: () => MealPlanVoteSchema,
+  MealPlanVoteTypeSchema: () => MealPlanVoteTypeSchema,
+  MyMealPlanGroupSchema: () => MyMealPlanGroupSchema,
+  MyMealPlanListItemSchema: () => MyMealPlanListItemSchema,
+  MyMealPlanListResponseSchema: () => MyMealPlanListResponseSchema,
+  NearbyFriendExposureEligibilitySchema: () => NearbyFriendExposureEligibilitySchema,
+  NearbyFriendMealPlanSummarySchema: () => NearbyFriendMealPlanSummarySchema,
+  ReopenMealPlanDecisionTaskRequestSchema: () => ReopenMealPlanDecisionTaskRequestSchema,
+  SendMealPlanChatMessageRequestSchema: () => SendMealPlanChatMessageRequestSchema,
+  SendMealPlanInviteResponseSchema: () => SendMealPlanInviteResponseSchema,
+  StartMealPlanFromGroupRequestSchema: () => StartMealPlanFromGroupRequestSchema,
+  UpdateMealGroupMemberRoleRequestSchema: () => UpdateMealGroupMemberRoleRequestSchema,
+  UpdateMealPlanContextRequestSchema: () => UpdateMealPlanContextRequestSchema,
+  compareMealPlanNotificationsByPriority: () => compareMealPlanNotificationsByPriority,
+  getMealPlanLiveActivityBehavior: () => getMealPlanLiveActivityBehavior,
+  getMealPlanNotificationPriority: () => getMealPlanNotificationPriority,
+  getMealPlanNotificationPriorityPolicy: () => getMealPlanNotificationPriorityPolicy,
+  shouldShowForegroundToast: () => shouldShowForegroundToast
+});
+module.exports = __toCommonJS(meal_plan_exports);
+
+// src/domain/meal-plan/meal-plan.schema.ts
+var import_zod12 = require("zod");
+
+// src/domain/common/schema/date.schema.ts
+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 TimeHHmmStringSchema = import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Expected time string in HH:mm format");
+
+// src/domain/common/schema/id.schema.ts
+var import_zod2 = require("zod");
+var PositiveIntIdSchema = import_zod2.z.number().int().positive();
+var NonEmptyStringIdSchema = import_zod2.z.string().min(1);
+var MemberIdSchema = PositiveIntIdSchema.brand();
+var ArticleIdSchema = PositiveIntIdSchema.brand();
+var CommentIdSchema = PositiveIntIdSchema.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();
+var FriendRequestIdSchema = PositiveIntIdSchema.brand();
+var ReferralCodeSchema = import_zod2.z.string().min(4).max(64).brand();
+var FoodCodeSchema = NonEmptyStringIdSchema.brand();
+var FoodLabelSchema = NonEmptyStringIdSchema.brand();
+var FoodSchema = import_zod2.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema
+});
+
+// src/domain/member/member.schema.ts
+var import_zod4 = require("zod");
+
+// src/domain/common/contracts/upload.ts
+var import_zod3 = __toESM(require("zod"), 1);
+var UploadPresignImageResponseSchema = import_zod3.default.object({
+  key: import_zod3.default.string(),
+  putUrl: import_zod3.default.string().url(),
+  cdnUrl: import_zod3.default.string().url()
+});
+var UploadPresignImageRequestSchema = import_zod3.default.object({
+  contentType: import_zod3.default.string()
+});
+
+// src/domain/member/member.schema.ts
+var MemberRoleSchema = import_zod4.z.enum(["USER", "ADMIN"]);
+var LocationConsentStatusSchema = import_zod4.z.enum(["UNKNOWN", "GRANTED", "DENIED"]);
+var OnboardingStatusSchema = import_zod4.z.enum(["REQUIRED", "COMPLETED"]);
+var PermissionKindSchema = import_zod4.z.enum(["LOCATION", "NOTIFICATION", "CAMERA"]);
+var PermissionStatusSchema = import_zod4.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED",
+  "LIMITED",
+  "UNSUPPORTED"
+]);
+var PermissionPlatformSchema = import_zod4.z.enum(["WEB", "IOS", "ANDROID", "UNKNOWN"]);
+var DevicePermissionSnapshotSchema = import_zod4.z.object({
+  kind: PermissionKindSchema,
+  status: PermissionStatusSchema,
+  platform: PermissionPlatformSchema.default("UNKNOWN"),
+  canAskAgain: import_zod4.z.boolean().optional(),
+  checkedAt: import_zod4.z.string().datetime()
+});
+var MemberLocationSchema = import_zod4.z.object({
+  latitude: import_zod4.z.number().min(-90).max(90),
+  longitude: import_zod4.z.number().min(-180).max(180),
+  accuracyMeters: import_zod4.z.number().min(0).nullable().optional(),
+  capturedAt: import_zod4.z.string().datetime()
+});
+var UpdateMemberLocationConsentRequestSchema = import_zod4.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod4.z.boolean().default(false),
+  mealSuggestionAllowed: import_zod4.z.boolean().optional(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.optional()
+});
+var MemberLocationSettingsResponseSchema = import_zod4.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod4.z.boolean(),
+  mealSuggestionAllowed: import_zod4.z.boolean(),
+  lastKnownLocation: MemberLocationSchema.nullable(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.nullable().optional(),
+  updatedAt: import_zod4.z.string().datetime().nullable()
+});
+var MemberCoreSchema = import_zod4.z.object({
+  memberId: MemberIdSchema,
+  username: import_zod4.z.string().min(1).max(50),
+  profileImageUrl: import_zod4.z.string().url().nullable().optional()
+});
+var UploadProfileImageResponseSchema = UploadPresignImageResponseSchema.extend({});
+var UploadProfileImageRequestSchema = UploadPresignImageRequestSchema.extend({});
+var MemberResponseSchema = MemberCoreSchema.pick({
+  memberId: true,
+  username: true,
+  profileImageUrl: true
+}).extend({
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod4.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.optional(),
+  nearbyMealPlanExposureAllowed: import_zod4.z.boolean().optional()
+});
+var MemberSearchQuerySchema = import_zod4.z.object({
+  email: import_zod4.z.string().email().optional(),
+  username: import_zod4.z.string().optional()
+});
+var MemberSerachResponseSchema = import_zod4.z.array(MemberCoreSchema);
+var MemberDetailSchema = MemberCoreSchema.extend({
+  bio: import_zod4.z.string().nullable(),
+  friendConunt: import_zod4.z.number().int().min(0).default(0),
+  completedPlans: import_zod4.z.number().int().min(0).default(0),
+  uncompletedPlans: import_zod4.z.number().int().min(0).default(0),
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod4.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.default("UNKNOWN"),
+  nearbyMealPlanExposureAllowed: import_zod4.z.boolean().default(false)
+});
+var FoodPreferenceItemSchema = FoodSchema.extend({});
+var MemberFoodPreferenceSchema = import_zod4.z.object({
+  liked: import_zod4.z.array(FoodPreferenceItemSchema).optional(),
+  disliked: import_zod4.z.array(FoodPreferenceItemSchema).optional(),
+  allergy: import_zod4.z.array(FoodPreferenceItemSchema).optional()
+});
+var UpdateProfileRequestSchema = import_zod4.z.object({
+  username: import_zod4.z.string().min(1).max(50),
+  profileImageUrl: import_zod4.z.string().url().nullable(),
+  bio: import_zod4.z.string().max(500).nullable()
+});
+var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
+var CompleteOnboardingRequestSchema = UpdateProfileRequestSchema.merge(
+  UpdatePreferenceRequestSchema
+);
+var OnboardingDraftSchema = import_zod4.z.object({
+  username: import_zod4.z.string().min(1).max(50).optional(),
+  profileImageUrl: import_zod4.z.string().url().nullable().optional(),
+  bio: import_zod4.z.string().max(500).nullable().optional(),
+  liked: import_zod4.z.array(FoodPreferenceItemSchema).optional(),
+  disliked: import_zod4.z.array(FoodPreferenceItemSchema).optional(),
+  allergy: import_zod4.z.array(FoodPreferenceItemSchema).optional()
+});
+
+// src/domain/restaurant/restaurant.schema.ts
+var import_zod5 = require("zod");
+var RestaurantSchema = import_zod5.z.object({
+  restaurantId: RestaurantIdSchema,
+  placeName: import_zod5.z.string(),
+  categoryName: import_zod5.z.string(),
+  categoryGroupName: import_zod5.z.string(),
+  distance: import_zod5.z.string().optional(),
+  roadAddressName: import_zod5.z.string(),
+  addressName: import_zod5.z.string(),
+  phone: import_zod5.z.string().nullable(),
+  placeUrl: import_zod5.z.string().url().nullable(),
+  lat: import_zod5.z.number(),
+  lng: import_zod5.z.number()
+});
+var KakaoPlaceRawSchema = import_zod5.z.object({
+  id: RestaurantIdSchema,
+  place_name: import_zod5.z.string(),
+  category_name: import_zod5.z.string(),
+  category_group_name: import_zod5.z.string(),
+  distance: import_zod5.z.string(),
+  road_address_name: import_zod5.z.string(),
+  address_name: import_zod5.z.string(),
+  phone: import_zod5.z.string(),
+  place_url: import_zod5.z.string().url().optional(),
+  lat: import_zod5.z.number(),
+  lng: import_zod5.z.number()
+});
+
+// src/domain/meal-plan/meal-plan-decision.schema.ts
+var import_zod7 = require("zod");
+
+// src/domain/food/food.schema.ts
+var import_zod6 = require("zod");
+var FoodGranularitySchema = import_zod6.z.enum(["main_dish", "side_dish", "beverage", "sauce"]);
+var CuisineTagSchema = import_zod6.z.enum([
+  "korean",
+  "western",
+  "chinese",
+  "japanese",
+  "mexican",
+  "indian",
+  "asian",
+  "snack",
+  "dessert",
+  "beverage",
+  "unknown"
+]);
+var FoodResolvedMatchSourceSchema = import_zod6.z.enum(["category", "alias", "lexical", "semantic"]);
+var FoodCodeManifestImageSchema = import_zod6.z.object({
+  src: import_zod6.z.string().min(1),
+  avifSrcset: import_zod6.z.string().min(1).optional(),
+  thumbhashDataURL: import_zod6.z.string().min(1).optional(),
+  aspectRatio: import_zod6.z.number().positive().optional()
+});
+var FoodCodeManifestItemSchema = import_zod6.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  aliases: import_zod6.z.array(import_zod6.z.string().min(1)).default([]),
+  parentCategory: import_zod6.z.string().min(1),
+  cuisineTags: import_zod6.z.array(CuisineTagSchema).default([]),
+  categoryTags: import_zod6.z.array(import_zod6.z.string().min(1)).default([]),
+  semanticTags: import_zod6.z.array(import_zod6.z.string().min(1)).default([]),
+  granularity: FoodGranularitySchema,
+  searchable: import_zod6.z.boolean(),
+  recommendable: import_zod6.z.boolean(),
+  previewEnabled: import_zod6.z.boolean(),
+  imageUrl: import_zod6.z.string().min(1).nullable().optional(),
+  image: FoodCodeManifestImageSchema.nullable().optional(),
+  popularity: import_zod6.z.number().nonnegative().optional(),
+  source: import_zod6.z.enum(["foodname", "manual", "foodai", "legacy"]).optional()
+});
+var FoodCodeManifestSchema = import_zod6.z.object({
+  version: import_zod6.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod6.z.string().min(1),
+  etag: import_zod6.z.string().min(1).optional(),
+  items: import_zod6.z.array(FoodCodeManifestItemSchema),
+  categoryIndex: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.array(FoodCodeSchema)),
+  aliasIndex: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.array(FoodCodeSchema)).optional()
+});
+var FoodImageIndexItemSchema = import_zod6.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  imageUrl: import_zod6.z.string().min(1).nullable(),
+  image: FoodCodeManifestImageSchema.nullable(),
+  source: import_zod6.z.enum(["foodname", "manual", "foodai", "legacy"]).optional()
+});
+var FoodImageIndexManifestSchema = import_zod6.z.object({
+  version: import_zod6.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod6.z.string().min(1),
+  items: import_zod6.z.array(FoodImageIndexItemSchema)
+});
+var ResolvedFoodCodeSchema = import_zod6.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  matchedBy: FoodResolvedMatchSourceSchema,
+  score: import_zod6.z.number(),
+  granularity: FoodGranularitySchema,
+  imageUrl: import_zod6.z.string().min(1).nullable().optional()
+});
+var BooleanQuerySchema = import_zod6.z.preprocess((value) => {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}, import_zod6.z.boolean());
+var FoodResolveQuerySchema = import_zod6.z.object({
+  q: import_zod6.z.string().default(""),
+  limit: import_zod6.z.coerce.number().int().min(1).max(100).optional().default(30),
+  recommendableOnly: BooleanQuerySchema.optional().default(true)
+});
+var FoodSearchQuerySchema = import_zod6.z.object({
+  q: import_zod6.z.string().default(""),
+  limit: import_zod6.z.coerce.number().int().min(1).max(100).optional().default(20)
+});
+var FoodResolveResponseSchema = import_zod6.z.object({
+  query: import_zod6.z.string(),
+  items: import_zod6.z.array(ResolvedFoodCodeSchema)
+});
+var FoodAiClassMappingStatusSchema = import_zod6.z.enum([
+  "exact",
+  "broad",
+  "narrow",
+  "merged",
+  "ignored",
+  "review_required"
+]);
+var AiClassFoodCodeMappingSchema = import_zod6.z.object({
+  classId: import_zod6.z.number().int().nonnegative(),
+  aiLabel: import_zod6.z.string().min(1),
+  aiAliases: import_zod6.z.array(import_zod6.z.string().min(1)).default([]),
+  representativeCode: FoodCodeSchema.nullable(),
+  candidateCodes: import_zod6.z.array(FoodCodeSchema).default([]),
+  mappingStatus: FoodAiClassMappingStatusSchema,
+  granularity: FoodGranularitySchema,
+  searchable: import_zod6.z.boolean(),
+  recommendable: import_zod6.z.boolean(),
+  reason: import_zod6.z.string().min(1).optional()
+});
+var AiClassToFoodCodeMapManifestSchema = import_zod6.z.object({
+  version: import_zod6.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  modelTaxonomyVersion: import_zod6.z.string().min(1),
+  serviceTaxonomyVersion: import_zod6.z.string().min(1),
+  classes: import_zod6.z.array(AiClassFoodCodeMappingSchema)
+});
+
+// src/domain/meal-plan/meal-plan-decision.schema.ts
+var MealPlanLatitudeSchema = import_zod7.z.number().brand();
+var MealPlanLongitudeSchema = import_zod7.z.number().brand();
+var MealPlanLocationCandidateIdSchema = import_zod7.z.string().min(1).brand();
+var MealPlanMenuCandidateIdSchema = import_zod7.z.string().min(1).brand();
+var MealPlanDecisionStageIdSchema = import_zod7.z.string().uuid().brand();
+var MealPlanVoteIdSchema = import_zod7.z.string().uuid().brand();
+var MealPlanLocationCandidateSourceSchema = import_zod7.z.enum([
+  "manual",
+  "map-marker",
+  "midpoint",
+  "user-location",
+  "search",
+  "recent-place",
+  "fallback"
+]);
+var MealPlanLocationCandidateSchema = import_zod7.z.object({
+  locationId: MealPlanLocationCandidateIdSchema,
+  placeName: import_zod7.z.string().min(1),
+  lat: MealPlanLatitudeSchema,
+  lng: MealPlanLongitudeSchema,
+  address: import_zod7.z.string().default(""),
+  source: MealPlanLocationCandidateSourceSchema.default("manual"),
+  createdBy: MemberIdSchema.optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanMenuCandidateSourceSchema = import_zod7.z.enum([
+  "external-recommendation",
+  "prefer-menu",
+  "recent-menu",
+  "fallback",
+  "manual-search"
+]);
+var MealPlanMenuCandidateSchema = import_zod7.z.object({
+  menuCandidateId: MealPlanMenuCandidateIdSchema,
+  menu: FoodSchema,
+  source: MealPlanMenuCandidateSourceSchema,
+  score: import_zod7.z.number().default(0),
+  imageUrl: import_zod7.z.string().min(1).nullable().default(null),
+  image: FoodCodeManifestImageSchema.nullable().default(null),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanRestaurantCandidateSchema = RestaurantSchema.extend({
+  candidateId: RestaurantIdSchema.optional(),
+  source: import_zod7.z.enum(["search", "fallback", "manual"]).optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanDecisionStageTypeSchema = import_zod7.z.enum([
+  "DATE",
+  "TIME",
+  "AREA",
+  "MENU",
+  "RESTAURANT",
+  "FINAL_CONFIRMATION"
+]);
+var MealPlanDecisionStageStatusSchema = import_zod7.z.enum([
+  "OPEN",
+  "COMPLETED",
+  "REOPENED"
+]);
+var MealPlanRestaurantSearchStatusSchema = import_zod7.z.enum([
+  "IDLE",
+  "PENDING",
+  "READY",
+  "FAILED",
+  "STALE"
+]);
+var MealPlanRestaurantSearchStateSchema = import_zod7.z.object({
+  searchKey: import_zod7.z.string().min(1).nullable(),
+  status: MealPlanRestaurantSearchStatusSchema,
+  startedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  version: import_zod7.z.number().int().min(0),
+  candidateCount: import_zod7.z.number().int().min(0),
+  errorMessage: import_zod7.z.string().nullable().default(null)
+});
+var MealPlanDecisionStageMetadataSchema = import_zod7.z.object({
+  restaurantSearch: MealPlanRestaurantSearchStateSchema.optional()
+}).catchall(import_zod7.z.unknown());
+var MealPlanVoteTypeSchema = import_zod7.z.enum([
+  "PICK",
+  "EXCLUDE",
+  "PREFER",
+  "READY"
+]);
+var MealPlanDecisionCandidateSchema = import_zod7.z.discriminatedUnion("stageType", [
+  import_zod7.z.object({ stageType: import_zod7.z.literal("DATE"), value: ISODateStringSchema }),
+  import_zod7.z.object({ stageType: import_zod7.z.literal("TIME"), value: TimeHHmmStringSchema }),
+  import_zod7.z.object({ stageType: import_zod7.z.literal("AREA"), value: MealPlanLocationCandidateSchema }),
+  import_zod7.z.object({ stageType: import_zod7.z.literal("MENU"), value: MealPlanMenuCandidateSchema }),
+  import_zod7.z.object({ stageType: import_zod7.z.literal("RESTAURANT"), value: MealPlanRestaurantCandidateSchema }),
+  import_zod7.z.object({ stageType: import_zod7.z.literal("FINAL_CONFIRMATION"), value: import_zod7.z.literal("READY") })
+]);
+var MealPlanVoteSchema = import_zod7.z.object({
+  voteId: MealPlanVoteIdSchema,
+  voterId: MemberIdSchema.nullable(),
+  guestId: import_zod7.z.string().min(1).nullable(),
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema,
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionStageResponseSchema = import_zod7.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanDecisionStageStatusSchema,
+  candidates: import_zod7.z.array(MealPlanDecisionCandidateSchema),
+  votes: import_zod7.z.array(MealPlanVoteSchema),
+  selectedCandidate: MealPlanDecisionCandidateSchema.nullable(),
+  metadata: MealPlanDecisionStageMetadataSchema.nullable().default(null),
+  openedAt: ISODateTimeStringSchema,
+  completedAt: ISODateTimeStringSchema.nullable(),
+  reopenedAt: ISODateTimeStringSchema.nullable()
+});
+var CreateMealPlanVoteRequestSchema = import_zod7.z.object({
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema
+});
+var CompleteMealPlanDecisionStageRequestSchema = import_zod7.z.object({
+  selectedCandidate: MealPlanDecisionCandidateSchema
+});
+var MealPlanChangeRequestStatusSchema = import_zod7.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanChangeRequestSchema = import_zod7.z.object({
+  stageType: MealPlanDecisionStageTypeSchema,
+  reason: import_zod7.z.string().min(1).max(500),
+  proposedCandidate: MealPlanDecisionCandidateSchema.optional()
+});
+var MealPlanChangeRequestSummarySchema = import_zod7.z.object({
+  changeRequestId: MealPlanChangeRequestIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanChangeRequestStatusSchema,
+  reason: import_zod7.z.string(),
+  requestedAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionTaskKeySchema = import_zod7.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_zod7.z.enum([
+  "LOCKED",
+  "OPEN",
+  "RESOLVED",
+  "STALE"
+]);
+var MealPlanDecisionFinalFieldSchema = import_zod7.z.enum([
+  "date",
+  "time",
+  "meetingAt",
+  "area",
+  "menu",
+  "restaurant"
+]);
+var MealPlanDecisionSnapshotStatusSchema = import_zod7.z.enum([
+  "CANDIDATE",
+  "PROVISIONAL",
+  "FINAL",
+  "STALE"
+]);
+var MealPlanDecisionReasonSchema = import_zod7.z.enum([
+  "COMMON_SCHEDULE",
+  "TOP_VOTED_LOCATION",
+  "TOP_PICKED_MENU",
+  "TOP_PICKED_RESTAURANT",
+  "OWNER_CONFIRMED",
+  "MANUAL_SELECTION"
+]);
+var MealPlanDecisionActorTypeSchema = import_zod7.z.enum(["MEMBER", "GUEST", "SYSTEM"]);
+var MealPlanDecisionSnapshotSchema = import_zod7.z.object({
+  snapshotId: import_zod7.z.string().uuid(),
+  mealPlanId: import_zod7.z.string().uuid(),
+  field: MealPlanDecisionFinalFieldSchema,
+  value: import_zod7.z.unknown(),
+  status: MealPlanDecisionSnapshotStatusSchema,
+  reason: MealPlanDecisionReasonSchema,
+  score: import_zod7.z.number().nullable().default(null),
+  sourceEvent: import_zod7.z.string().min(1),
+  sourceActorType: MealPlanDecisionActorTypeSchema,
+  sourceMemberId: MemberIdSchema.nullable(),
+  sourceGuestId: import_zod7.z.string().min(1).nullable(),
+  sourceParticipantId: import_zod7.z.string().uuid().nullable(),
+  sourceVersion: import_zod7.z.number().int().min(0),
+  dependencyHash: import_zod7.z.string().min(1),
+  dependencyFields: import_zod7.z.array(MealPlanDecisionFinalFieldSchema),
+  createdAt: ISODateTimeStringSchema,
+  staleAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanDecisionTaskProgressSchema = import_zod7.z.object({
+  taskKey: MealPlanDecisionTaskKeySchema,
+  status: MealPlanDecisionTaskStatusSchema,
+  blockers: import_zod7.z.array(import_zod7.z.string()).default([]),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionProgressSchema = import_zod7.z.object({
+  mealPlanId: import_zod7.z.string().uuid(),
+  status: import_zod7.z.string().min(1),
+  tasks: import_zod7.z.array(MealPlanDecisionTaskProgressSchema),
+  final: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()),
+  provisional: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()),
+  snapshots: import_zod7.z.array(MealPlanDecisionSnapshotSchema),
+  version: import_zod7.z.number().int().min(0),
+  updatedAt: ISODateTimeStringSchema
+});
+var ReopenMealPlanDecisionTaskRequestSchema = import_zod7.z.object({
+  reason: import_zod7.z.string().max(500).optional()
+});
+var ConfirmMealPlanDecisionSnapshotRequestSchema = import_zod7.z.object({
+  snapshotId: import_zod7.z.string().uuid()
+});
+
+// src/domain/meal-plan/meal-plan-participant.schema.ts
+var import_zod8 = require("zod");
+var MealPlanParticipantIdSchema = import_zod8.z.string().uuid().brand();
+var MealPlanParticipantRoleSchema = import_zod8.z.enum([
+  "OWNER",
+  "FRIEND",
+  "GUEST"
+]);
+var MealPlanParticipantStatusSchema = import_zod8.z.enum([
+  "INVITED",
+  "REQUESTED",
+  "JOINED",
+  "READY",
+  "DECLINED",
+  "LEFT",
+  "REMOVED"
+]);
+var MealPlanJoinSourceSchema = import_zod8.z.enum([
+  "OWNER",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+var MealPlanGuestParticipantSchema = import_zod8.z.object({
+  guestId: import_zod8.z.string().min(1),
+  nickname: import_zod8.z.string().min(1).max(50)
+});
+var MealPlanParticipantResponseSchema = import_zod8.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_zod8.z.object({
+  memberId: MemberIdSchema.optional(),
+  guestNickname: import_zod8.z.string().min(1).max(50).optional(),
+  source: MealPlanJoinSourceSchema
+});
+
+// src/domain/meal-plan/meal-plan-invite.schema.ts
+var import_zod9 = require("zod");
+var MealPlanInviteStatusSchema = import_zod9.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "DECLINED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var CreateMealPlanInviteRequestSchema = import_zod9.z.object({
+  inviteeId: MemberIdSchema,
+  message: import_zod9.z.string().max(500).default("")
+});
+var MealPlanInviteSummarySchema = import_zod9.z.object({
+  inviteId: MealPlanInviteIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  inviter: MemberCoreSchema,
+  invitee: MemberCoreSchema,
+  status: MealPlanInviteStatusSchema,
+  message: import_zod9.z.string().max(500),
+  createdAt: ISODateTimeStringSchema,
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanInviteListResponseSchema = import_zod9.z.array(MealPlanInviteSummarySchema);
+var SendMealPlanInviteResponseSchema = import_zod9.z.object({
+  inviteId: MealPlanInviteIdSchema
+});
+
+// src/domain/meal-plan/meal-plan-nearby-friend.schema.ts
+var import_zod10 = require("zod");
+var MealPlanNearbyFriendExposureIdSchema = import_zod10.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureStatusSchema = import_zod10.z.enum([
+  "OPEN",
+  "CLOSED",
+  "EXPIRED"
+]);
+var MealPlanNearbyFriendExposureNotificationStatusSchema = import_zod10.z.enum([
+  "PENDING",
+  "SENT",
+  "PARTIAL",
+  "FAILED",
+  "SKIPPED"
+]);
+var ExposeMealPlanToNearbyFriendsRequestSchema = import_zod10.z.object({
+  radiusMeters: import_zod10.z.number().int().min(100).max(5e3).default(1e3),
+  expiresAt: ISODateTimeStringSchema.optional()
+});
+var NearbyFriendExposureEligibilitySchema = import_zod10.z.object({
+  canExpose: import_zod10.z.boolean(),
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod10.z.boolean(),
+  mealSuggestionAllowed: import_zod10.z.boolean(),
+  hasLastKnownLocation: import_zod10.z.boolean(),
+  missingRequirements: import_zod10.z.array(import_zod10.z.enum([
+    "LOCATION_PERMISSION",
+    "SERVICE_LOCATION_CONSENT",
+    "NEARBY_EXPOSURE_TOGGLE",
+    "MEAL_SUGGESTION_TOGGLE",
+    "LAST_KNOWN_LOCATION"
+  ]))
+});
+var MealPlanNearbyFriendRejectionReasonSchema = import_zod10.z.enum([
+  "NOT_FRIEND",
+  "BLOCKED",
+  "LOCATION_CONSENT_REQUIRED",
+  "LOCATION_UNAVAILABLE",
+  "OUT_OF_RADIUS",
+  "MEAL_SUGGESTION_DISABLED",
+  "NOT_HUNGRY"
+]);
+var MealPlanNearbyFriendRejectionSummarySchema = import_zod10.z.object({
+  reason: MealPlanNearbyFriendRejectionReasonSchema,
+  count: import_zod10.z.number().int().min(0)
+});
+var ExposeMealPlanToNearbyFriendsResponseSchema = import_zod10.z.object({
+  mealPlanId: MealPlanIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  exposedFriendCount: import_zod10.z.number().int().min(0),
+  rejectedFriendCount: import_zod10.z.number().int().min(0),
+  notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
+  rejectionSummary: import_zod10.z.array(MealPlanNearbyFriendRejectionSummarySchema)
+});
+var MealPlanNearbyFriendExposureSummarySchema = import_zod10.z.object({
+  exposureId: MealPlanNearbyFriendExposureIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema.nullable(),
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  radiusMeters: import_zod10.z.number().int().min(100),
+  exposedFriendCount: import_zod10.z.number().int().min(0),
+  openedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  closedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanNearbyFriendExposureBatchSummarySchema = import_zod10.z.object({
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  radiusMeters: import_zod10.z.number().int().min(100),
+  exposedFriendCount: import_zod10.z.number().int().min(0),
+  rejectedFriendCount: import_zod10.z.number().int().min(0),
+  rejectionSummary: import_zod10.z.array(MealPlanNearbyFriendRejectionSummarySchema),
+  notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
+  notificationSentAt: ISODateTimeStringSchema.nullable(),
+  openedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  closedAt: ISODateTimeStringSchema.nullable()
+});
+var MealPlanJoinRequestStatusSchema = import_zod10.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanJoinRequestSchema = import_zod10.z.object({
+  message: import_zod10.z.string().max(500).default("")
+});
+var MealPlanJoinRequestSummarySchema = import_zod10.z.object({
+  joinRequestId: MealPlanJoinRequestIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  requester: MemberCoreSchema,
+  status: MealPlanJoinRequestStatusSchema,
+  message: import_zod10.z.string().max(500),
+  requestedAt: ISODateTimeStringSchema,
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+var NearbyFriendMealPlanSummarySchema = import_zod10.z.object({
+  mealPlanId: MealPlanIdSchema,
+  owner: MemberCoreSchema,
+  title: import_zod10.z.string(),
+  participantCount: import_zod10.z.number().int().min(1),
+  distanceMeters: import_zod10.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_zod11 = require("zod");
+var MealPlanChatMessageKindSchema = import_zod11.z.enum([
+  "USER",
+  "SYSTEM"
+]);
+var MealPlanSystemMessageKindSchema = import_zod11.z.enum([
+  "PARTICIPANT_JOINED",
+  "PARTICIPANT_READY",
+  "PARTICIPANT_REMOVED",
+  "STATUS_CHANGED",
+  "DECISION_UPDATED",
+  "CONFIRMED",
+  "RECORD_NEEDED"
+]);
+var MealPlanChatSystemPayloadSchema = import_zod11.z.object({
+  kind: MealPlanSystemMessageKindSchema
+}).catchall(import_zod11.z.unknown());
+var MealPlanChatMessageListResponseSchema = import_zod11.z.array(
+  import_zod11.z.lazy(() => MealPlanChatMessageResponseSchema)
+);
+var MealPlanChatRoomSummarySchema = import_zod11.z.object({
+  chatRoomId: MealPlanChatRoomIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  messageCount: import_zod11.z.number().int().min(0),
+  lastMessageAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var SendMealPlanChatMessageRequestSchema = import_zod11.z.object({
+  message: import_zod11.z.string().min(1).max(500)
+});
+var MealPlanChatMessageResponseSchema = import_zod11.z.object({
+  messageId: MealPlanChatMessageIdSchema,
+  chatRoomId: MealPlanChatRoomIdSchema,
+  sender: MemberCoreSchema.nullable(),
+  guestId: import_zod11.z.string().min(1).nullable(),
+  guestNickname: import_zod11.z.string().min(1).nullable(),
+  kind: MealPlanChatMessageKindSchema,
+  message: import_zod11.z.string().min(1).max(1e3),
+  systemPayload: MealPlanChatSystemPayloadSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSystemMessageSchema = import_zod11.z.object({
+  kind: MealPlanSystemMessageKindSchema,
+  message: import_zod11.z.string().min(1),
+  createdAt: ISODateTimeStringSchema
+});
+
+// src/domain/meal-plan/meal-plan.schema.ts
+var MealPlanStatusSchema = import_zod12.z.enum([
+  "DRAFT",
+  "RECOMMENDING",
+  "GATHERING",
+  "DECIDING",
+  "READY",
+  "CONFIRMED",
+  "LOCKED",
+  "COMPLETED",
+  "RECORDED",
+  "CANCELLED"
+]);
+var MealPlanChannelSchema = import_zod12.z.enum([
+  "OWNER_ONLY",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+var MealPlanRecommendationContextSchema = import_zod12.z.object({
+  mealDate: ISODateStringSchema.optional(),
+  mealTime: TimeHHmmStringSchema.optional(),
+  area: MealPlanLocationCandidateSchema.optional(),
+  preferredMenuCategories: import_zod12.z.array(import_zod12.z.string().min(1)).default([]),
+  excludedMenuCategories: import_zod12.z.array(import_zod12.z.string().min(1)).default([]),
+  candidateMenuCategories: import_zod12.z.array(import_zod12.z.string().min(1)).default([]),
+  budgetMin: import_zod12.z.number().int().min(0).optional(),
+  budgetMax: import_zod12.z.number().int().min(0).optional(),
+  memo: import_zod12.z.string().max(500).optional()
+});
+var CreateMealPlanRequestSchema = import_zod12.z.object({
+  title: import_zod12.z.string().min(1).max(100).optional(),
+  channels: import_zod12.z.array(MealPlanChannelSchema).default(["OWNER_ONLY"]),
+  recommendationContext: MealPlanRecommendationContextSchema.optional()
+});
+var CreateMealPlanResponseSchema = import_zod12.z.object({
+  mealPlanId: MealPlanIdSchema
+});
+var UpdateMealPlanContextRequestSchema = MealPlanRecommendationContextSchema.partial();
+var MealPlanViewerRoleSchema = import_zod12.z.enum([
+  "OWNER",
+  "FRIEND",
+  "GUEST",
+  "NONE"
+]);
+var MealPlanViewerPermissionsSchema = import_zod12.z.object({
+  canView: import_zod12.z.boolean(),
+  canInviteFriends: import_zod12.z.boolean(),
+  canManageParticipants: import_zod12.z.boolean(),
+  canCreateShareLink: import_zod12.z.boolean(),
+  canExposeNearbyFriends: import_zod12.z.boolean(),
+  canVote: import_zod12.z.boolean(),
+  canChat: import_zod12.z.boolean(),
+  canReadyMealPlan: import_zod12.z.boolean(),
+  canRequestChange: import_zod12.z.boolean(),
+  canReopenDecisionTask: import_zod12.z.boolean(),
+  canConfirmDecisionSnapshot: import_zod12.z.boolean(),
+  canConfirmMealPlan: import_zod12.z.boolean(),
+  canCompleteMealPlan: import_zod12.z.boolean(),
+  canRecordMealPlan: import_zod12.z.boolean(),
+  canCancelMealPlan: import_zod12.z.boolean()
+});
+var MealPlanResponseSchema = import_zod12.z.object({
+  mealPlanId: MealPlanIdSchema,
+  owner: MemberCoreSchema,
+  title: import_zod12.z.string().nullable(),
+  status: MealPlanStatusSchema,
+  channels: import_zod12.z.array(MealPlanChannelSchema),
+  participants: import_zod12.z.array(MealPlanParticipantResponseSchema),
+  pendingInvites: import_zod12.z.array(MealPlanInviteSummarySchema),
+  pendingJoinRequests: import_zod12.z.array(MealPlanJoinRequestSummarySchema),
+  decisionStages: import_zod12.z.array(MealPlanDecisionStageResponseSchema),
+  decisionProgress: MealPlanDecisionProgressSchema.nullable(),
+  viewerRole: MealPlanViewerRoleSchema,
+  viewerParticipantStatus: MealPlanParticipantStatusSchema.nullable(),
+  viewerPermissions: MealPlanViewerPermissionsSchema,
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  selectedArea: MealPlanLocationCandidateSchema.nullable(),
+  selectedRestaurant: RestaurantSchema.nullable(),
+  selectedMenuCategory: import_zod12.z.string().nullable(),
+  chatRoom: MealPlanChatRoomSummarySchema.nullable(),
+  confirmedAt: ISODateTimeStringSchema.nullable(),
+  lockedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  recordedAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var MyMealPlanGroupSchema = import_zod12.z.enum(["DECIDING", "UPCOMING", "RECORD_NEEDED", "PAST"]);
+var MyMealPlanListItemSchema = import_zod12.z.object({
+  mealPlanId: MealPlanIdSchema,
+  group: MyMealPlanGroupSchema,
+  title: import_zod12.z.string(),
+  status: MealPlanStatusSchema,
+  channels: import_zod12.z.array(MealPlanChannelSchema),
+  participantCount: import_zod12.z.number().int().min(1),
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  selectedAreaName: import_zod12.z.string().nullable(),
+  selectedRestaurantName: import_zod12.z.string().nullable(),
+  primaryAction: import_zod12.z.object({
+    label: import_zod12.z.string(),
+    href: import_zod12.z.string()
+  }),
+  updatedAt: ISODateTimeStringSchema
+});
+var MyMealPlanListResponseSchema = import_zod12.z.object({
+  deciding: import_zod12.z.array(MyMealPlanListItemSchema),
+  upcoming: import_zod12.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod12.z.array(MyMealPlanListItemSchema),
+  past: import_zod12.z.array(MyMealPlanListItemSchema)
+});
+var MealPlanNotificationKindSchema = import_zod12.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_zod12.z.enum([
+  "HOME",
+  "NOTIFICATION_INBOX",
+  "FCM_PUSH",
+  "LIVE_ACTIVITY"
+]);
+var MealPlanLiveActivityBehaviorSchema = import_zod12.z.enum([
+  "NONE",
+  "START_OR_UPDATE",
+  "UPDATE",
+  "END"
+]);
+var MealPlanNotificationPriorityPolicyItemSchema = import_zod12.z.object({
+  kind: MealPlanNotificationKindSchema,
+  priority: import_zod12.z.number().int().min(0),
+  homePriority: import_zod12.z.number().int().min(0),
+  inboxPriority: import_zod12.z.number().int().min(0),
+  fcmPriority: import_zod12.z.number().int().min(0),
+  liveActivityPriority: import_zod12.z.number().int().min(0),
+  liveActivityBehavior: MealPlanLiveActivityBehaviorSchema,
+  foregroundToast: import_zod12.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_zod12.z.object({
+  notificationId: import_zod12.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  deepLink: import_zod12.z.string().min(1),
+  title: import_zod12.z.string().min(1),
+  message: import_zod12.z.string().min(1),
+  createdAt: ISODateTimeStringSchema,
+  readAt: ISODateTimeStringSchema.nullable()
+});
+
+// src/domain/meal-plan/meal-plan-share-link.schema.ts
+var import_zod13 = require("zod");
+var CreateMealPlanShareLinkRequestSchema = import_zod13.z.object({
+  expiresAt: ISODateTimeStringSchema.optional(),
+  guestJoinEnabled: import_zod13.z.boolean().default(true)
+});
+var MealPlanShareLinkSummarySchema = import_zod13.z.object({
+  shareLinkId: MealPlanShareLinkIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  url: import_zod13.z.string().url(),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod13.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSharePreviewResponseSchema = import_zod13.z.object({
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  title: import_zod13.z.string(),
+  ownerName: import_zod13.z.string(),
+  participantCount: import_zod13.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod13.z.boolean()
+});
+var JoinMealPlanGuestRequestSchema = import_zod13.z.object({
+  nickname: import_zod13.z.string().min(1).max(50),
+  password: import_zod13.z.string().min(1).max(100).optional()
+});
+var JoinMealPlanGuestResponseSchema = import_zod13.z.object({
+  mealPlanId: MealPlanIdSchema,
+  guestId: import_zod13.z.string().min(1),
+  sessionToken: import_zod13.z.string().min(1)
+});
+var MealPlanGuestSessionQuerySchema = import_zod13.z.object({
+  sessionToken: import_zod13.z.string().min(1)
+});
+var MealPlanGuestSessionResponseSchema = import_zod13.z.object({
+  mealPlan: MealPlanResponseSchema,
+  token: MealPlanShareLinkTokenSchema,
+  guestId: import_zod13.z.string().min(1),
+  nickname: import_zod13.z.string().min(1).max(50),
+  sessionToken: import_zod13.z.string().min(1)
+});
+
+// src/domain/meal-plan/meal-group.schema.ts
+var import_zod14 = require("zod");
+var MealGroupMemberRoleSchema = import_zod14.z.enum([
+  "OWNER",
+  "MEMBER"
+]);
+var MealGroupMemberSchema = import_zod14.z.object({
+  member: MemberCoreSchema,
+  role: MealGroupMemberRoleSchema,
+  joinedAt: ISODateTimeStringSchema
+});
+var MealGroupResponseSchema = import_zod14.z.object({
+  mealGroupId: MealGroupIdSchema,
+  name: import_zod14.z.string().min(1).max(50),
+  owner: MemberCoreSchema,
+  profileImageUrl: import_zod14.z.string().url().nullable(),
+  members: import_zod14.z.array(MealGroupMemberSchema),
+  recentMealPlanIds: import_zod14.z.array(MealPlanIdSchema),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var CreateMealGroupRequestSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1).max(50),
+  memberIds: import_zod14.z.array(import_zod14.z.number().int().positive()).min(1),
+  profileImageUrl: import_zod14.z.string().url().nullable().optional(),
+  sourceMealPlanId: MealPlanIdSchema.optional()
+});
+var StartMealPlanFromGroupRequestSchema = import_zod14.z.object({
+  title: import_zod14.z.string().min(1).max(100).optional()
+});
+var AddMealGroupMemberRequestSchema = import_zod14.z.object({
+  memberId: import_zod14.z.number().int().positive(),
+  role: MealGroupMemberRoleSchema.default("MEMBER")
+});
+var UpdateMealGroupMemberRoleRequestSchema = import_zod14.z.object({
+  role: MealGroupMemberRoleSchema
+});
+var MealGroupHistoryItemSchema = MyMealPlanListItemSchema.extend({});
+var MealGroupPreferenceSummarySchema = import_zod14.z.object({
+  mealGroupId: MealGroupIdSchema,
+  frequentMenuCategories: import_zod14.z.array(import_zod14.z.object({ label: import_zod14.z.string(), count: import_zod14.z.number().int().min(0) })),
+  frequentRestaurants: import_zod14.z.array(import_zod14.z.object({ restaurantName: import_zod14.z.string(), count: import_zod14.z.number().int().min(0) })),
+  recentMenuCategories: import_zod14.z.array(import_zod14.z.string()),
+  recommendationContext: import_zod14.z.object({
+    preferredMenuCategories: import_zod14.z.array(import_zod14.z.string()),
+    excludedMenuCategories: import_zod14.z.array(import_zod14.z.string()),
+    candidateMenuCategories: import_zod14.z.array(import_zod14.z.string())
+  })
+});
+var MealGroupHistoryResponseSchema = import_zod14.z.array(MealGroupHistoryItemSchema);
+
+// src/domain/meal-plan/meal-plan-home-map.schema.ts
+var import_zod15 = require("zod");
+var HomeMealPlanActionKindSchema = import_zod15.z.enum([
+  "CONTINUE_DECISION",
+  "TODAY_UPCOMING",
+  "RECORD_NEEDED",
+  "RESPOND_JOIN_REQUEST",
+  "NOTIFICATION_FOLLOW_UP"
+]);
+var HomeMealPlanActionCardSchema = import_zod15.z.object({
+  actionId: import_zod15.z.string().min(1),
+  kind: HomeMealPlanActionKindSchema,
+  priority: import_zod15.z.number().int().min(0),
+  title: import_zod15.z.string().min(1),
+  description: import_zod15.z.string().min(1),
+  primaryAction: import_zod15.z.object({
+    label: import_zod15.z.string().min(1),
+    href: import_zod15.z.string().min(1)
+  }),
+  mealPlan: MyMealPlanListItemSchema.nullable(),
+  joinRequest: MealPlanJoinRequestSummarySchema.nullable(),
+  notification: MealPlanNotificationSchema.nullable().default(null)
+});
+var HomeMealPlanDashboardResponseSchema = import_zod15.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  inProgress: import_zod15.z.array(MyMealPlanListItemSchema),
+  today: import_zod15.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod15.z.array(MyMealPlanListItemSchema),
+  pendingJoinRequests: import_zod15.z.array(MealPlanJoinRequestSummarySchema),
+  unreadNotifications: import_zod15.z.array(MealPlanNotificationSchema).default([]),
+  nextActions: import_zod15.z.array(HomeMealPlanActionCardSchema)
+});
+var MealMapLayerSchema = import_zod15.z.enum([
+  "MY_MEAL_PLAN_PLACE",
+  "NEARBY_FRIEND_MEAL_PLAN",
+  "FRIEND_RECORD_LOCATION",
+  "RESTAURANT_CANDIDATE"
+]);
+var MealMapMarkerBaseSchema = import_zod15.z.object({
+  markerId: import_zod15.z.string().min(1),
+  lat: import_zod15.z.number().min(-90).max(90),
+  lng: import_zod15.z.number().min(-180).max(180),
+  title: import_zod15.z.string().min(1),
+  subtitle: import_zod15.z.string().nullable(),
+  href: import_zod15.z.string().min(1).nullable(),
+  mealPlanId: MealPlanIdSchema.nullable(),
+  articleId: ArticleIdSchema.nullable(),
+  restaurant: RestaurantSchema.nullable(),
+  distanceMeters: import_zod15.z.number().int().min(0).nullable(),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealMapMyMealPlanPlaceMetadataSchema = import_zod15.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod15.z.string().min(1),
+  participantCount: import_zod15.z.number().int().min(1),
+  source: import_zod15.z.string().min(1)
+});
+var MealMapNearbyFriendMealPlanMetadataSchema = import_zod15.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  ownerName: import_zod15.z.string().min(1),
+  participantCount: import_zod15.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  source: import_zod15.z.string().min(1)
+});
+var MealMapFriendRecordLocationMetadataSchema = import_zod15.z.object({
+  authorId: MemberIdSchema.nullable().default(null),
+  authorName: import_zod15.z.string().min(1),
+  imageUrl: import_zod15.z.string().nullable().default(null),
+  mealDate: import_zod15.z.string().min(1)
+});
+var MealMapRestaurantCandidateCompletionBlockedReasonSchema = import_zod15.z.enum([
+  "OWNER_ONLY",
+  "STAGE_ALREADY_COMPLETED",
+  "MEAL_PLAN_NOT_MUTABLE"
+]);
+var MealMapRestaurantCandidateMetadataSchema = import_zod15.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod15.z.string().min(1),
+  source: import_zod15.z.enum(["search", "fallback", "manual"]).default("search"),
+  stageStatus: import_zod15.z.enum(["OPEN", "COMPLETED", "REOPENED"]).default("OPEN"),
+  canVote: import_zod15.z.boolean().default(false),
+  canCompleteStage: import_zod15.z.boolean().default(false),
+  completionBlockedReason: MealMapRestaurantCandidateCompletionBlockedReasonSchema.nullable().default(null)
+});
+var MealMapMarkerSchema = import_zod15.z.discriminatedUnion("layer", [
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod15.z.literal("MY_MEAL_PLAN_PLACE"),
+    metadata: MealMapMyMealPlanPlaceMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod15.z.literal("NEARBY_FRIEND_MEAL_PLAN"),
+    metadata: MealMapNearbyFriendMealPlanMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod15.z.literal("FRIEND_RECORD_LOCATION"),
+    metadata: MealMapFriendRecordLocationMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod15.z.literal("RESTAURANT_CANDIDATE"),
+    metadata: MealMapRestaurantCandidateMetadataSchema
+  })
+]);
+var MealMapQuerySchema = import_zod15.z.object({
+  friendRecordDays: import_zod15.z.coerce.number().int().min(1).max(90).optional().default(7)
+});
+var MealMapResponseSchema = import_zod15.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  center: import_zod15.z.object({
+    lat: import_zod15.z.number().min(-90).max(90),
+    lng: import_zod15.z.number().min(-180).max(180),
+    source: import_zod15.z.enum(["LAST_KNOWN_LOCATION", "MY_MEAL_PLAN", "DEFAULT"])
+  }),
+  layers: import_zod15.z.object({
+    myMealPlanPlaces: import_zod15.z.array(MealMapMarkerSchema),
+    nearbyFriendMealPlans: import_zod15.z.array(MealMapMarkerSchema),
+    friendRecordLocations: import_zod15.z.array(MealMapMarkerSchema),
+    restaurantCandidates: import_zod15.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;
+}
+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;
+  }
+}
+function getMealPlanLiveActivityBehavior(kind) {
+  return getMealPlanNotificationPriorityPolicy(kind).liveActivityBehavior;
+}
+function shouldShowForegroundToast(kind) {
+  return getMealPlanNotificationPriorityPolicy(kind).foregroundToast;
+}
+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();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddMealGroupMemberRequestSchema,
+  CompleteMealPlanDecisionStageRequestSchema,
+  ConfirmMealPlanDecisionSnapshotRequestSchema,
+  CreateMealGroupRequestSchema,
+  CreateMealPlanChangeRequestSchema,
+  CreateMealPlanInviteRequestSchema,
+  CreateMealPlanJoinRequestSchema,
+  CreateMealPlanParticipantRequestSchema,
+  CreateMealPlanRequestSchema,
+  CreateMealPlanResponseSchema,
+  CreateMealPlanShareLinkRequestSchema,
+  CreateMealPlanVoteRequestSchema,
+  ExposeMealPlanToNearbyFriendsRequestSchema,
+  ExposeMealPlanToNearbyFriendsResponseSchema,
+  HomeMealPlanActionCardSchema,
+  HomeMealPlanActionKindSchema,
+  HomeMealPlanDashboardResponseSchema,
+  JoinMealPlanGuestRequestSchema,
+  JoinMealPlanGuestResponseSchema,
+  MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES,
+  MealGroupHistoryItemSchema,
+  MealGroupHistoryResponseSchema,
+  MealGroupMemberRoleSchema,
+  MealGroupMemberSchema,
+  MealGroupPreferenceSummarySchema,
+  MealGroupResponseSchema,
+  MealMapFriendRecordLocationMetadataSchema,
+  MealMapLayerSchema,
+  MealMapMarkerSchema,
+  MealMapMyMealPlanPlaceMetadataSchema,
+  MealMapNearbyFriendMealPlanMetadataSchema,
+  MealMapQuerySchema,
+  MealMapResponseSchema,
+  MealMapRestaurantCandidateCompletionBlockedReasonSchema,
+  MealMapRestaurantCandidateMetadataSchema,
+  MealPlanChangeRequestStatusSchema,
+  MealPlanChangeRequestSummarySchema,
+  MealPlanChannelSchema,
+  MealPlanChatMessageKindSchema,
+  MealPlanChatMessageListResponseSchema,
+  MealPlanChatMessageResponseSchema,
+  MealPlanChatRoomSummarySchema,
+  MealPlanChatSystemPayloadSchema,
+  MealPlanDecisionActorTypeSchema,
+  MealPlanDecisionCandidateSchema,
+  MealPlanDecisionFinalFieldSchema,
+  MealPlanDecisionProgressSchema,
+  MealPlanDecisionReasonSchema,
+  MealPlanDecisionSnapshotSchema,
+  MealPlanDecisionSnapshotStatusSchema,
+  MealPlanDecisionStageIdSchema,
+  MealPlanDecisionStageMetadataSchema,
+  MealPlanDecisionStageResponseSchema,
+  MealPlanDecisionStageStatusSchema,
+  MealPlanDecisionStageTypeSchema,
+  MealPlanDecisionTaskKeySchema,
+  MealPlanDecisionTaskProgressSchema,
+  MealPlanDecisionTaskStatusSchema,
+  MealPlanGuestParticipantSchema,
+  MealPlanGuestSessionQuerySchema,
+  MealPlanGuestSessionResponseSchema,
+  MealPlanInviteListResponseSchema,
+  MealPlanInviteStatusSchema,
+  MealPlanInviteSummarySchema,
+  MealPlanJoinRequestStatusSchema,
+  MealPlanJoinRequestSummarySchema,
+  MealPlanJoinSourceSchema,
+  MealPlanLatitudeSchema,
+  MealPlanLiveActivityBehaviorSchema,
+  MealPlanLocationCandidateIdSchema,
+  MealPlanLocationCandidateSchema,
+  MealPlanLocationCandidateSourceSchema,
+  MealPlanLongitudeSchema,
+  MealPlanMenuCandidateIdSchema,
+  MealPlanMenuCandidateSchema,
+  MealPlanMenuCandidateSourceSchema,
+  MealPlanNearbyFriendExposureBatchSummarySchema,
+  MealPlanNearbyFriendExposureIdSchema,
+  MealPlanNearbyFriendExposureNotificationStatusSchema,
+  MealPlanNearbyFriendExposureStatusSchema,
+  MealPlanNearbyFriendExposureSummarySchema,
+  MealPlanNearbyFriendRejectionReasonSchema,
+  MealPlanNearbyFriendRejectionSummarySchema,
+  MealPlanNotificationKindSchema,
+  MealPlanNotificationPriorityChannelSchema,
+  MealPlanNotificationPriorityPolicyItemSchema,
+  MealPlanNotificationSchema,
+  MealPlanParticipantIdSchema,
+  MealPlanParticipantResponseSchema,
+  MealPlanParticipantRoleSchema,
+  MealPlanParticipantStatusSchema,
+  MealPlanRecommendationContextSchema,
+  MealPlanResponseSchema,
+  MealPlanRestaurantCandidateSchema,
+  MealPlanRestaurantSearchStateSchema,
+  MealPlanRestaurantSearchStatusSchema,
+  MealPlanShareLinkSummarySchema,
+  MealPlanSharePreviewResponseSchema,
+  MealPlanStatusSchema,
+  MealPlanSystemMessageKindSchema,
+  MealPlanSystemMessageSchema,
+  MealPlanViewerPermissionsSchema,
+  MealPlanViewerRoleSchema,
+  MealPlanVoteIdSchema,
+  MealPlanVoteSchema,
+  MealPlanVoteTypeSchema,
+  MyMealPlanGroupSchema,
+  MyMealPlanListItemSchema,
+  MyMealPlanListResponseSchema,
+  NearbyFriendExposureEligibilitySchema,
+  NearbyFriendMealPlanSummarySchema,
+  ReopenMealPlanDecisionTaskRequestSchema,
+  SendMealPlanChatMessageRequestSchema,
+  SendMealPlanInviteResponseSchema,
+  StartMealPlanFromGroupRequestSchema,
+  UpdateMealGroupMemberRoleRequestSchema,
+  UpdateMealPlanContextRequestSchema,
+  compareMealPlanNotificationsByPriority,
+  getMealPlanLiveActivityBehavior,
+  getMealPlanNotificationPriority,
+  getMealPlanNotificationPriorityPolicy,
+  shouldShowForegroundToast
+});