@kimdaegyu/babmukdang-shared 1.1.11 → 2.0.3

package/dist/domain/push/index.cjs

@@ -0,0 +1,1055 @@
+"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/push/index.ts
+var push_exports = {};
+__export(push_exports, {
+  MealPlanPushPayloadDataSchema: () => MealPlanPushPayloadDataSchema,
+  PushDeliveryAttemptResultSchema: () => PushDeliveryAttemptResultSchema,
+  PushDeliveryAttemptSummarySchema: () => PushDeliveryAttemptSummarySchema,
+  PushDeliveryOutboxSummarySchema: () => PushDeliveryOutboxSummarySchema,
+  PushDeliveryStatusSchema: () => PushDeliveryStatusSchema,
+  PushPayloadSchemaVersionSchema: () => PushPayloadSchemaVersionSchema,
+  PushPermissionStatusSchema: () => PushPermissionStatusSchema,
+  PushPlatformSchema: () => PushPlatformSchema,
+  PushProviderSchema: () => PushProviderSchema,
+  PushTokenResponseSchema: () => PushTokenResponseSchema,
+  PushTokenStatusSchema: () => PushTokenStatusSchema,
+  RegisterPushTokenRequestSchema: () => RegisterPushTokenRequestSchema,
+  RevokePushTokenRequestSchema: () => RevokePushTokenRequestSchema
+});
+module.exports = __toCommonJS(push_exports);
+
+// src/domain/push/push.schema.ts
+var import_zod13 = 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/meal-plan/meal-plan.schema.ts
+var import_zod12 = require("zod");
+
+// 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 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/push/push.schema.ts
+var PushProviderSchema = import_zod13.z.enum(["FCM", "APNS_LIVE_ACTIVITY"]);
+var PushPlatformSchema = import_zod13.z.enum(["WEB", "ANDROID", "IOS"]);
+var PushPermissionStatusSchema = import_zod13.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED"
+]);
+var PushTokenStatusSchema = import_zod13.z.enum(["ACTIVE", "REVOKED", "DISABLED"]);
+var RegisterPushTokenRequestSchema = import_zod13.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  platform: PushPlatformSchema,
+  token: import_zod13.z.string().min(10),
+  deviceId: import_zod13.z.string().min(1).max(128),
+  appVersion: import_zod13.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod13.z.string().min(1).max(64).optional(),
+  permissionStatus: PushPermissionStatusSchema
+});
+var RevokePushTokenRequestSchema = import_zod13.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  token: import_zod13.z.string().min(10).optional(),
+  deviceId: import_zod13.z.string().min(1).max(128).optional()
+});
+var PushTokenResponseSchema = import_zod13.z.object({
+  pushTokenId: import_zod13.z.string().uuid(),
+  provider: PushProviderSchema,
+  platform: PushPlatformSchema,
+  deviceId: import_zod13.z.string(),
+  status: PushTokenStatusSchema,
+  permissionStatus: PushPermissionStatusSchema,
+  appVersion: import_zod13.z.string().nullable(),
+  buildNumber: import_zod13.z.string().nullable(),
+  lastSeenAt: ISODateTimeStringSchema,
+  revokedAt: ISODateTimeStringSchema.nullable()
+});
+var PushPayloadSchemaVersionSchema = import_zod13.z.literal("2026-06-17");
+var MealPlanPushPayloadDataSchema = import_zod13.z.object({
+  schemaVersion: PushPayloadSchemaVersionSchema,
+  notificationId: import_zod13.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  deepLink: import_zod13.z.string().min(1),
+  title: import_zod13.z.string().min(1),
+  body: import_zod13.z.string().min(1),
+  fcmPriority: import_zod13.z.coerce.number().int().min(0),
+  liveActivityPriority: import_zod13.z.coerce.number().int().min(0),
+  liveActivityBehavior: MealPlanLiveActivityBehaviorSchema
+});
+var PushDeliveryStatusSchema = import_zod13.z.enum([
+  "PENDING",
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptResultSchema = import_zod13.z.enum([
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptSummarySchema = import_zod13.z.object({
+  attemptId: import_zod13.z.string().uuid(),
+  outboxId: import_zod13.z.string().uuid(),
+  pushTokenId: import_zod13.z.string().uuid().nullable(),
+  provider: PushProviderSchema,
+  result: PushDeliveryAttemptResultSchema,
+  providerMessageId: import_zod13.z.string().nullable(),
+  errorCode: import_zod13.z.string().nullable(),
+  errorMessage: import_zod13.z.string().nullable(),
+  invalidToken: import_zod13.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var PushDeliveryOutboxSummarySchema = import_zod13.z.object({
+  outboxId: import_zod13.z.string().uuid(),
+  notificationId: import_zod13.z.string().min(1),
+  memberId: import_zod13.z.number().int().positive(),
+  status: PushDeliveryStatusSchema,
+  attemptCount: import_zod13.z.number().int().min(0),
+  lastError: import_zod13.z.string().nullable(),
+  nextAttemptAt: ISODateTimeStringSchema.nullable(),
+  sentAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MealPlanPushPayloadDataSchema,
+  PushDeliveryAttemptResultSchema,
+  PushDeliveryAttemptSummarySchema,
+  PushDeliveryOutboxSummarySchema,
+  PushDeliveryStatusSchema,
+  PushPayloadSchemaVersionSchema,
+  PushPermissionStatusSchema,
+  PushPlatformSchema,
+  PushProviderSchema,
+  PushTokenResponseSchema,
+  PushTokenStatusSchema,
+  RegisterPushTokenRequestSchema,
+  RevokePushTokenRequestSchema
+});