@kimdaegyu/babmukdang-shared 1.1.4 → 1.1.11

package/dist/domain/common/index.cjs

@@ -83,7 +83,7 @@ __export(common_exports, {
 module.exports = __toCommonJS(common_exports);
 
 // src/domain/common/contracts/api.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/domain/article/article.schema.ts
 var import_zod7 = require("zod");
@@ -144,11 +144,14 @@ var import_zod5 = require("zod");
 
 // src/domain/common/contracts/upload.ts
 var import_zod4 = __toESM(require("zod"), 1);
-var PresignUploadResponseSchema = import_zod4.default.object({
+var UploadPresignImageResponseSchema = import_zod4.default.object({
   key: import_zod4.default.string(),
   putUrl: import_zod4.default.string().url(),
   cdnUrl: import_zod4.default.string().url()
 });
+var UploadPresignImageRequestSchema = import_zod4.default.object({
+  contentType: import_zod4.default.string()
+});
 
 // src/domain/member/member.schema.ts
 var MemberRoleSchema = import_zod5.z.enum(["USER", "ADMIN"]);
@@ -157,7 +160,8 @@ var MemberCoreSchema = import_zod5.z.object({
   username: import_zod5.z.string().min(1).max(50),
   profileImageUrl: import_zod5.z.string().url().nullable().optional()
 });
-var PresignProfileResponseSchema = PresignUploadResponseSchema.extend({});
+var UploadProfileImageResponseSchema = UploadPresignImageResponseSchema.extend({});
+var UploadProfileImageRequestSchema = UploadPresignImageRequestSchema.extend({});
 var MemberResponseSchema = MemberCoreSchema.pick({
   memberId: true,
   username: true,
@@ -226,7 +230,8 @@ var ArticleListQuerySchema = PageQuerySchema.extend({
   sortBy: ArticleSortBySchema.optional().default("createdAt"),
   direction: SortDirectionSchema.optional().default("desc")
 });
-var PresignArticleResponseSchema = PresignUploadResponseSchema.extend({});
+var UploadArticleImageResponseSchema = UploadPresignImageResponseSchema.extend({});
+var UploadArticleImageRequestSchema = UploadPresignImageRequestSchema.extend({});
 var FoodAnalysisResultSchema = FoodSchema.extend({
   confidence: import_zod7.z.number().min(0).max(1),
   tsUtc: ISODateTimeStringSchema.optional()
@@ -278,8 +283,7 @@ var PageArticleSummaryResponseSchema = PageResponseSchema(ArticleSummaryResponse
 // src/domain/auth/auth.schema.ts
 var import_zod8 = require("zod");
 var TokenResponseSchema = import_zod8.z.object({
-  accessToken: import_zod8.z.string().min(1),
-  accessTokenMaxAge: import_zod8.z.number().int().positive()
+  accessToken: import_zod8.z.string().min(1)
 });
 var LoginRequestSchema = import_zod8.z.object({
   email: import_zod8.z.string().email(),
@@ -308,7 +312,10 @@ var MonthProgressSchema = import_zod9.z.object({
   goal: import_zod9.z.number().int().positive()
 });
 var ChallengeStatusResponseSchema = import_zod9.z.object({
-  count: import_zod9.z.number().int().min(0)
+  week: WeekProgressSchema,
+  month: MonthProgressSchema,
+  weekRewardAvailable: import_zod9.z.boolean(),
+  monthRewardAvailable: import_zod9.z.boolean()
 });
 var ClaimChallengeRewardRequestSchema = import_zod9.z.object({
   type: RewardTypeSchema
@@ -318,9 +325,35 @@ var ClaimChallengeRewardResponseSchema = import_zod9.z.object({
   claimed: import_zod9.z.boolean()
 });
 
-// src/domain/friend/friend.schema.ts
+// src/domain/common/schema/envelope.schema.ts
 var import_zod10 = require("zod");
-var FriendRequestStatusSchema = import_zod10.z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
+var NoContentSchema = import_zod10.z.null();
+var ApiSuccessSchema = (data) => import_zod10.z.object({
+  success: import_zod10.z.literal(true),
+  code: import_zod10.z.number().int(),
+  message: import_zod10.z.string(),
+  data
+});
+var ApiFailureSchema = import_zod10.z.object({
+  success: import_zod10.z.literal(false),
+  status: import_zod10.z.number().int(),
+  code: import_zod10.z.string(),
+  message: import_zod10.z.string()
+});
+var ApiResponseSchema = (data) => import_zod10.z.union([ApiSuccessSchema(data), ApiFailureSchema]);
+var CreatedEntityIdResponseSchema = import_zod10.z.discriminatedUnion("entity", [
+  import_zod10.z.object({ entity: import_zod10.z.literal("article"), id: ArticleIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("comment"), id: CommentIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("recruit"), id: RecruitIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("invitation"), id: InvitationIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("subscription"), id: SubscriptionIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("coupon"), id: CouponIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("plan"), id: PlanIdSchema })
+]);
+
+// src/domain/friend/friend.schema.ts
+var import_zod11 = require("zod");
+var FriendRequestStatusSchema = import_zod11.z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
 var FriendListItemResponseSchema = MemberCoreSchema.extend({
   friendSince: ISODateTimeStringSchema
 });
@@ -328,77 +361,79 @@ var FriendBlockItemResponseSchema = MemberCoreSchema.extend({
   blockedAt: ISODateTimeStringSchema
 });
 var FriendRequestMemberSchema = MemberCoreSchema;
-var FriendRequestItemResponseSchema = import_zod10.z.object({
+var FriendRequestItemResponseSchema = import_zod11.z.object({
   requestId: FriendRequestIdSchema,
   requester: FriendRequestMemberSchema,
   recipient: FriendRequestMemberSchema,
   status: FriendRequestStatusSchema,
   requestedAt: ISODateTimeStringSchema
 });
+var FriendSearchQuerySchema = import_zod11.z.string().min(1).max(50);
+var FriendSearchResponseSchema = import_zod11.z.array(MemberCoreSchema);
 
 // src/domain/invitation/invitation.schema.ts
-var import_zod11 = require("zod");
-var CreateInvitationRequestSchema = import_zod11.z.object({
+var import_zod12 = require("zod");
+var CreateInvitationRequestSchema = import_zod12.z.object({
   inviteeId: MemberIdSchema,
-  message: import_zod11.z.string().min(1).max(500)
+  message: import_zod12.z.string().min(1).max(500)
 });
-var InvitationListItemResponseSchema = import_zod11.z.object({
+var InvitationListItemResponseSchema = import_zod12.z.object({
   invitationId: InvitationIdSchema,
-  inviterName: import_zod11.z.string(),
-  inviterProfileImageUrl: import_zod11.z.string().url().nullable().optional()
+  inviterName: import_zod12.z.string(),
+  inviterProfileImageUrl: import_zod12.z.string().url().nullable().optional()
 });
-var SendInvitationResponseSchema = import_zod11.z.object({
+var SendInvitationResponseSchema = import_zod12.z.object({
   invitationId: InvitationIdSchema
 });
-var AcceptInvitationResponseSchema = import_zod11.z.object({
+var AcceptInvitationResponseSchema = import_zod12.z.object({
   invitationId: InvitationIdSchema,
-  room: import_zod11.z.object({
-    type: import_zod11.z.literal("invitation"),
+  room: import_zod12.z.object({
+    type: import_zod12.z.literal("invitation"),
     roomId: RoomIdSchema
   })
 });
 
 // src/domain/meal/meal.schema.ts
-var import_zod12 = require("zod");
-var MealStatusResponseSchema = import_zod12.z.object({
-  hungry: import_zod12.z.boolean(),
-  label: import_zod12.z.string(),
+var import_zod13 = require("zod");
+var MealStatusResponseSchema = import_zod13.z.object({
+  hungry: import_zod13.z.boolean(),
+  label: import_zod13.z.string(),
   updatedAt: ISODateStringSchema,
-  secondsToAutoOff: import_zod12.z.number().int().min(0)
+  secondsToAutoOff: import_zod13.z.number().int().min(0)
 });
-var MealStatusActionSchema = import_zod12.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
-var UpdateMealStatusRequestSchema = import_zod12.z.object({
+var MealStatusActionSchema = import_zod13.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
+var UpdateMealStatusRequestSchema = import_zod13.z.object({
   action: MealStatusActionSchema.optional().default("SET_MANNUALY")
 });
-var MealStatusSchema = import_zod12.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
-var FriendMealQuerySchema = import_zod12.z.object({
+var MealStatusSchema = import_zod13.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
+var FriendMealQuerySchema = import_zod13.z.object({
   status: MealStatusSchema.optional().default("ALL")
 });
 var FriendMealItemResponseSchema = MemberCoreSchema.extend({
-  hungry: import_zod12.z.boolean(),
-  label: import_zod12.z.string(),
+  hungry: import_zod13.z.boolean(),
+  label: import_zod13.z.string(),
   updatedAt: ISODateStringSchema
 });
 
 // src/domain/plan/plan.schema.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/domain/room/schema/room.schema.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var MenuCodeSchema = FoodCodeSchema;
-var LocationIdSchema = import_zod13.z.string().min(1).brand();
+var LocationIdSchema = import_zod14.z.string().min(1).brand();
 var MenuSchema = FoodSchema.extend({});
-var LocationCandidateSchema = import_zod13.z.object({
+var LocationCandidateSchema = import_zod14.z.object({
   locationId: LocationIdSchema,
-  placeName: import_zod13.z.string(),
-  lat: import_zod13.z.number(),
-  lng: import_zod13.z.number(),
-  address: import_zod13.z.string()
+  placeName: import_zod14.z.string(),
+  lat: import_zod14.z.number(),
+  lng: import_zod14.z.number(),
+  address: import_zod14.z.string()
 });
 var ParticipantSchema = MemberCoreSchema.extend({
-  ready: import_zod13.z.boolean()
+  ready: import_zod14.z.boolean()
 });
-var RecruitRoomStageSchema = import_zod13.z.enum([
+var RecruitRoomStageSchema = import_zod14.z.enum([
   "waiting",
   "location",
   "location-vote",
@@ -407,7 +442,8 @@ var RecruitRoomStageSchema = import_zod13.z.enum([
   "restaurant",
   "finish"
 ]);
-var InvitationRoomStageSchema = import_zod13.z.enum([
+var RoomTypeSchema = import_zod14.z.enum(["recruit", "invitation"]);
+var InvitationRoomStageSchema = import_zod14.z.enum([
   "waiting",
   "date",
   "time",
@@ -418,163 +454,207 @@ var InvitationRoomStageSchema = import_zod13.z.enum([
   "restaurant",
   "finish"
 ]);
-var ReadyStateRequestSchema = import_zod13.z.object({
-  isReady: import_zod13.z.boolean()
-});
-var ChatMessageRequestSchema = import_zod13.z.object({
-  message: import_zod13.z.string().min(1).max(500)
-});
-var VoteLocationRequestSchema = import_zod13.z.object({ locationId: LocationIdSchema });
-var ExcludeMenuRequestSchema = import_zod13.z.object({ menu: MenuSchema });
-var PickMenuRequestSchema = import_zod13.z.object({ menuCode: MenuCodeSchema });
-var PickRestaurantRequestSchema = import_zod13.z.object({ restaurantId: RestaurantIdSchema });
-var PickTimesRequestSchema = import_zod13.z.object({ times: import_zod13.z.array(import_zod13.z.string().min(1)).min(1) });
-var PickDateRequestSchema = import_zod13.z.object({ dates: import_zod13.z.array(ISODateStringSchema).min(1) });
-var RoomAssignedResponseSchema = import_zod13.z.object({
+var ReadyStateRequestSchema = import_zod14.z.object({
+  isReady: import_zod14.z.boolean()
+});
+var ChatMessageRequestSchema = import_zod14.z.object({
+  message: import_zod14.z.string().min(1).max(500)
+});
+var VoteLocationRequestSchema = import_zod14.z.object({ locationId: LocationIdSchema });
+var ExcludeMenuRequestSchema = import_zod14.z.object({ menu: MenuSchema });
+var PickMenuRequestSchema = import_zod14.z.object({ menuCode: MenuCodeSchema });
+var PickRestaurantRequestSchema = import_zod14.z.object({ restaurantId: RestaurantIdSchema });
+var PickTimesRequestSchema = import_zod14.z.object({ times: import_zod14.z.array(import_zod14.z.string().min(1)).min(1) });
+var PickDateRequestSchema = import_zod14.z.object({ dates: import_zod14.z.array(ISODateStringSchema).min(1) });
+var RoomAssignedResponseSchema = import_zod14.z.object({
   roomId: RoomIdSchema
 });
-var RoomSocketErrorSchema = import_zod13.z.object({
-  code: import_zod13.z.string(),
-  message: import_zod13.z.string()
+var RoomAccessResponseSchema = import_zod14.z.object({
+  roomId: RoomIdSchema,
+  roomType: RoomTypeSchema,
+  stage: import_zod14.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
+  canJoin: import_zod14.z.boolean()
+});
+var MatchingNotificationKindSchema = import_zod14.z.enum(["recruit", "invitation"]);
+var MatchingNotificationSchema = import_zod14.z.object({
+  notificationId: import_zod14.z.string().min(1),
+  kind: MatchingNotificationKindSchema,
+  roomId: RoomIdSchema,
+  roomType: RoomTypeSchema,
+  title: import_zod14.z.string().min(1),
+  message: import_zod14.z.string().min(1),
+  createdAt: ISODateTimeStringSchema,
+  readAt: ISODateTimeStringSchema.nullable()
+});
+var RoomSocketErrorSchema = import_zod14.z.object({
+  code: import_zod14.z.string(),
+  message: import_zod14.z.string()
 });
-var ChatMessageResponseSchema = import_zod13.z.object({
-  messageId: import_zod13.z.string(),
+var ChatMessageResponseSchema = import_zod14.z.object({
+  messageId: import_zod14.z.string(),
   user: MemberCoreSchema,
-  message: import_zod13.z.string(),
+  message: import_zod14.z.string(),
   createdAt: ISODateTimeStringSchema
 });
-var ReadyStateChangedSchema = import_zod13.z.object({
-  readyCount: import_zod13.z.number().int().min(0),
-  participantCount: import_zod13.z.number().int().min(0)
+var ReadyStateChangedSchema = import_zod14.z.object({
+  readyCount: import_zod14.z.number().int().min(0),
+  participantCount: import_zod14.z.number().int().min(0)
 });
-var FinalStateSchema = import_zod13.z.object({
+var FinalStateSchema = import_zod14.z.object({
   location: LocationCandidateSchema.optional(),
-  excludeMenu: import_zod13.z.array(MenuSchema).optional(),
+  excludeMenu: import_zod14.z.array(MenuSchema).optional(),
   menu: MenuSchema.optional(),
   restaurant: RestaurantSchema.optional(),
-  time: import_zod13.z.string().optional(),
+  time: import_zod14.z.string().optional(),
   date: ISODateStringSchema.optional()
 });
-var RoomInitialStateSchema = import_zod13.z.object({
-  participants: import_zod13.z.array(ParticipantSchema),
-  chat: import_zod13.z.array(ChatMessageResponseSchema),
+var RoomInitialStateSchema = import_zod14.z.object({
+  participants: import_zod14.z.array(ParticipantSchema),
+  chat: import_zod14.z.array(ChatMessageResponseSchema),
   final: FinalStateSchema
 });
-var PhaseDataBroadcastSchema = import_zod13.z.object({
-  phase: import_zod13.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
-  data: import_zod13.z.unknown()
-});
-var TimePicksUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ memberId: MemberIdSchema, times: import_zod13.z.array(import_zod13.z.string()) })
+var TimePicksUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ memberId: MemberIdSchema, times: import_zod14.z.array(import_zod14.z.string()) })
 );
-var DatePicksUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ memberId: MemberIdSchema, dates: import_zod13.z.array(ISODateStringSchema) })
+var DatePicksUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ memberId: MemberIdSchema, dates: import_zod14.z.array(ISODateStringSchema) })
 );
-var LocationCandidateAddUpdateResponseSchema = import_zod13.z.array(
+var LocationCandidateAddUpdateResponseSchema = import_zod14.z.array(
   LocationCandidateSchema.extend({ authorMemberId: MemberIdSchema })
 );
-var LocationCandidateVoteUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ locationId: LocationIdSchema, votes: import_zod13.z.array(MemberIdSchema) })
+var LocationCandidateVoteUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ locationId: LocationIdSchema, votes: import_zod14.z.array(MemberIdSchema) })
 );
-var ExcludeMenuUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ memberId: MemberIdSchema, exclusions: import_zod13.z.array(MenuSchema) })
+var ExcludeMenuUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ memberId: MemberIdSchema, exclusions: import_zod14.z.array(MenuSchema) })
 );
-var MenuPickUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod13.z.array(MemberIdSchema) })
+var MenuPickUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
 );
-var RestaurantPickUpdateResponseSchema = import_zod13.z.array(
-  import_zod13.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod13.z.array(MemberIdSchema) })
+var RestaurantPickUpdateResponseSchema = import_zod14.z.array(
+  import_zod14.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
 );
+var WaitingPhaseDataSchema = import_zod14.z.object({
+  locationInitial: import_zod14.z.string().optional(),
+  meetingAt: ISODateTimeStringSchema.optional()
+});
+var LocationVotePhaseDataSchema = import_zod14.z.object({
+  locations: LocationCandidateAddUpdateResponseSchema,
+  votes: LocationCandidateVoteUpdateResponseSchema
+});
+var ExcludeMenuPhaseDataSchema = import_zod14.z.object({
+  recentMenus: import_zod14.z.array(import_zod14.z.object({ userId: import_zod14.z.string(), menuList: import_zod14.z.array(MenuSchema) })),
+  excludedMenuList: ExcludeMenuUpdateResponseSchema
+});
+var MenuPhaseDataSchema = import_zod14.z.object({
+  initialMenus: import_zod14.z.array(MenuSchema),
+  menuPick: MenuPickUpdateResponseSchema
+});
+var RestaurantPhaseDataSchema = import_zod14.z.object({
+  initialRestaurants: import_zod14.z.array(RestaurantSchema),
+  restaurantUserList: RestaurantPickUpdateResponseSchema
+});
+var PhaseDataBroadcastSchema = import_zod14.z.discriminatedUnion("phase", [
+  import_zod14.z.object({ phase: import_zod14.z.literal("waiting"), data: WaitingPhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("date"), data: DatePicksUpdateResponseSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("time"), data: TimePicksUpdateResponseSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("location"), data: WaitingPhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("location-vote"), data: LocationVotePhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("exclude-menu"), data: ExcludeMenuPhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("menu"), data: MenuPhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("restaurant"), data: RestaurantPhaseDataSchema }),
+  import_zod14.z.object({ phase: import_zod14.z.literal("finish"), data: WaitingPhaseDataSchema })
+]);
 
 // src/domain/plan/plan.schema.ts
-var PlanStatusSchema = import_zod14.z.enum(["PLANNING", "COMPLETED"]);
-var PlanTypeSchema = import_zod14.z.enum(["RECRUIT", "INVITATION"]);
-var PlanResponseSchema = import_zod14.z.object({
+var PlanStatusSchema = import_zod15.z.enum(["PLANNING", "COMPLETED"]);
+var PlanTypeSchema = import_zod15.z.enum(["RECRUIT", "INVITATION"]);
+var PlanResponseSchema = import_zod15.z.object({
   planId: PlanIdSchema,
   meetingAt: ISODateTimeStringSchema,
   location: LocationCandidateSchema.nullable(),
   restaurant: RestaurantSchema.nullable(),
   author: MemberCoreSchema,
-  participants: import_zod14.z.array(MemberCoreSchema),
+  participants: import_zod15.z.array(MemberCoreSchema),
   status: PlanStatusSchema,
   type: PlanTypeSchema,
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
-var PlanListQuerySchema = import_zod14.z.object({});
+var PlanListQuerySchema = import_zod15.z.object({});
 
 // src/domain/recruit/recruit.schema.ts
-var import_zod15 = require("zod");
-var RecruitStatusSchema = import_zod15.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
+var import_zod16 = require("zod");
+var RecruitStatusSchema = import_zod16.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
 var RecruitParticipantSchema = MemberCoreSchema.extend({});
-var RecruitSortBySchema = import_zod15.z.enum(["createdAt", "deadline", "participantCount"]);
+var RecruitSortBySchema = import_zod16.z.enum(["createdAt", "deadline", "participantCount"]);
 var RecruitListQuerySchema = PageQuerySchema.extend({
   sortBy: RecruitSortBySchema.default("createdAt"),
   direction: SortDirectionSchema.default("desc")
 });
-var RecruitResponseSchema = import_zod15.z.object({
-  targetCount: import_zod15.z.number().int().min(2),
+var RecruitResponseSchema = import_zod16.z.object({
+  targetCount: import_zod16.z.number().int().min(2),
   meetingAt: ISODateTimeStringSchema,
-  location: import_zod15.z.string().min(1),
-  message: import_zod15.z.string().max(500),
+  location: import_zod16.z.string().min(1),
+  message: import_zod16.z.string().max(500),
   recruitId: RecruitIdSchema,
   status: RecruitStatusSchema,
   createdAt: ISODateTimeStringSchema,
   expiredAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema,
   author: MemberCoreSchema,
-  participants: import_zod15.z.array(RecruitParticipantSchema)
+  participants: import_zod16.z.array(RecruitParticipantSchema)
 });
-var RecruitListResponseSchema = import_zod15.z.array(RecruitResponseSchema);
-var CreateRecruitRequestSchema = import_zod15.z.object({
-  targetCount: import_zod15.z.number().int().min(2),
+var RecruitListResponseSchema = PageResponseSchema(RecruitResponseSchema);
+var CreateRecruitRequestSchema = import_zod16.z.object({
+  targetCount: import_zod16.z.number().int().min(2),
   meetingAt: ISODateTimeStringSchema,
-  location: import_zod15.z.string().min(1),
-  message: import_zod15.z.string().max(500)
+  location: import_zod16.z.string().min(1),
+  message: import_zod16.z.string().max(500)
 });
-var CreateRecruitResponseSchema = import_zod15.z.object({
+var CreateRecruitResponseSchema = import_zod16.z.object({
   recruitId: RecruitIdSchema
 });
 
 // src/domain/promotion/referral.schema.ts
-var import_zod16 = require("zod");
-var ReferralCreateResponseSchema = import_zod16.z.object({
+var import_zod17 = require("zod");
+var ReferralCreateResponseSchema = import_zod17.z.object({
   code: ReferralCodeSchema,
-  link: import_zod16.z.string().url(),
+  link: import_zod17.z.string().url(),
   expiresAt: ISODateTimeStringSchema
 });
-var ReferralItemResponseSchema = import_zod16.z.object({
+var ReferralItemResponseSchema = import_zod17.z.object({
   code: ReferralCodeSchema,
   createdAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  used: import_zod16.z.boolean(),
+  used: import_zod17.z.boolean(),
   usedByMemberId: MemberIdSchema.nullable(),
-  usedByUsername: import_zod16.z.string().nullable()
+  usedByUsername: import_zod17.z.string().nullable()
 });
-var RedeemReferralRequestSchema = import_zod16.z.object({
+var RedeemReferralRequestSchema = import_zod17.z.object({
   code: ReferralCodeSchema
 });
 
 // src/domain/promotion/coupon.schema.ts
-var import_zod17 = require("zod");
-var CouponTypeSchema = import_zod17.z.enum(["DISCOUNT", "SERVICE"]);
-var CouponStatusSchema = import_zod17.z.enum(["UNUSED", "USED"]);
-var CouponResponseSchema = import_zod17.z.object({
+var import_zod18 = require("zod");
+var CouponTypeSchema = import_zod18.z.enum(["DISCOUNT", "SERVICE"]);
+var CouponStatusSchema = import_zod18.z.enum(["UNUSED", "USED"]);
+var CouponResponseSchema = import_zod18.z.object({
   couponId: CouponIdSchema,
-  title: import_zod17.z.string(),
-  shopName: import_zod17.z.string(),
+  title: import_zod18.z.string(),
+  shopName: import_zod18.z.string(),
   type: CouponTypeSchema,
-  condition: import_zod17.z.string(),
+  condition: import_zod18.z.string(),
   expiresAt: ISODateStringSchema,
-  used: import_zod17.z.boolean(),
-  thumbnailUrl: import_zod17.z.string().url()
+  used: import_zod18.z.boolean(),
+  thumbnailUrl: import_zod18.z.string().url()
 });
 
 // src/domain/common/contracts/endpoint.ts
-var import_zod18 = require("zod");
-var NoBodySchema = import_zod18.z.undefined();
-var NoQuerySchema = import_zod18.z.undefined();
-var NoParamsSchema = import_zod18.z.undefined();
+var import_zod19 = require("zod");
+var NoBodySchema = import_zod19.z.undefined();
+var NoQuerySchema = import_zod19.z.undefined();
+var NoParamsSchema = import_zod19.z.undefined();
 var endpoint = (contract) => ({
   method: contract.method,
   path: contract.path,
@@ -585,28 +665,30 @@ var endpoint = (contract) => ({
 });
 
 // src/domain/common/contracts/api.ts
-var memberIdParam = import_zod19.z.object({ memberId: MemberIdSchema });
-var articleIdParam = import_zod19.z.object({ articleId: ArticleIdSchema });
-var commentIdParam = import_zod19.z.object({ commentId: CommentIdSchema });
-var recruitIdParam = import_zod19.z.object({ recruitId: RecruitIdSchema });
-var invitationIdParam = import_zod19.z.object({ invitationId: InvitationIdSchema });
-var planIdParam = import_zod19.z.object({ planId: PlanIdSchema });
-var couponIdParam = import_zod19.z.object({ couponId: CouponIdSchema });
-var friendRequestIdParam = import_zod19.z.object({ requestId: FriendRequestIdSchema });
+var memberIdParam = import_zod20.z.object({ memberId: MemberIdSchema });
+var articleIdParam = import_zod20.z.object({ articleId: ArticleIdSchema });
+var commentIdParam = import_zod20.z.object({ commentId: CommentIdSchema });
+var recruitIdParam = import_zod20.z.object({ recruitId: RecruitIdSchema });
+var roomIdParam = import_zod20.z.object({ roomId: RoomIdSchema });
+var invitationIdParam = import_zod20.z.object({ invitationId: InvitationIdSchema });
+var notificationIdParam = import_zod20.z.object({ notificationId: import_zod20.z.string().min(1) });
+var planIdParam = import_zod20.z.object({ planId: PlanIdSchema });
+var couponIdParam = import_zod20.z.object({ couponId: CouponIdSchema });
+var friendRequestIdParam = import_zod20.z.object({ requestId: FriendRequestIdSchema });
 var apiContract = {
   auth: {
     signup: endpoint({ method: "POST", path: "/auth/signup", body: SignupRequestSchema, response: SignupResponseSchema }),
     login: endpoint({ method: "POST", path: "/auth/login", body: LoginRequestSchema, response: TokenResponseSchema }),
     refresh: endpoint({ method: "POST", path: "/auth/refresh", response: TokenResponseSchema }),
     logout: endpoint({ method: "POST", path: "/auth/logout", response: NoContentSchema })
-    // test: endpoint({method: "GET",  path: "/auth/test", response: TokenResponseSchema}) TODO: Dev에서만 작동하도록 백엔드에서 수정해야함 
+    // test: endpoint({method: "GET",  path: "/auth/test", response: TokenResponseSchema}) TODO: Dev에서만 작동하도록 백엔드에서 수정해야함
   },
   members: {
     me: endpoint({ method: "GET", path: "/members/me", response: MemberResponseSchema }),
-    myProfile: endpoint({ method: "GET", path: "/members/me/detail", response: ProfileDetailResponseSchema }),
+    myProfile: endpoint({ method: "GET", path: "/members/me/profile", response: ProfileDetailResponseSchema }),
     search: endpoint({ method: "GET", path: "/members/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
-    memberProfile: endpoint({ method: "GET", path: "/members/:memberId", pathParams: memberIdParam, response: ProfileDetailResponseSchema }),
-    presignProfileImage: endpoint({ method: "POST", path: "/uploads/presign-profile", response: PresignProfileResponseSchema }),
+    memberProfile: endpoint({ method: "GET", path: "/members/:memberId/profile", pathParams: memberIdParam, response: ProfileDetailResponseSchema }),
+    presignProfileImage: endpoint({ method: "POST", path: "/uploads/presign-profile", body: UploadProfileImageRequestSchema, response: UploadProfileImageResponseSchema }),
     createProfile: endpoint({ method: "POST", path: "/members/onboarding", body: CreateProfileRequestSchema, response: NoContentSchema }),
     updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, response: NoContentSchema })
   },
@@ -615,9 +697,9 @@ var apiContract = {
     update: endpoint({ method: "PATCH", path: "/preferences/me", body: UpdatePreferenceRequestSchema, response: NoContentSchema })
   },
   mealStatus: {
-    my: endpoint({ method: "GET", path: "/meal-status", response: MealStatusResponseSchema }),
-    updateMealStatus: endpoint({ method: "PATCH", path: "/meal-status", body: UpdateMealStatusRequestSchema, response: NoContentSchema }),
-    friendMealStatus: endpoint({ method: "GET", path: "/meal-status/friend", query: FriendMealQuerySchema, response: import_zod19.z.array(FriendMealItemResponseSchema) })
+    my: endpoint({ method: "GET", path: "/members/me/meal-status", response: MealStatusResponseSchema }),
+    updateMealStatus: endpoint({ method: "PATCH", path: "/members/me/meal-status", body: UpdateMealStatusRequestSchema, response: NoContentSchema }),
+    friendMealStatus: endpoint({ method: "GET", path: "/friends/me/meals", query: FriendMealQuerySchema, response: import_zod20.z.array(FriendMealItemResponseSchema) })
   },
   articles: {
     list: endpoint({ method: "GET", path: "/articles/home", query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
@@ -627,7 +709,7 @@ var apiContract = {
     create: endpoint({ method: "POST", path: "/articles", body: CreateArticleRequestSchema, response: CreatedEntityIdResponseSchema }),
     like: endpoint({ method: "POST", path: "/articles/:articleId/like", pathParams: articleIdParam, response: ArticleLikeResponseSchema }),
     createComment: endpoint({ method: "POST", path: "/articles/:articleId/comments", pathParams: articleIdParam, body: CreateCommentRequestSchema, response: CreatedEntityIdResponseSchema }),
-    presignArticleImage: endpoint({ method: "POST", path: "/uploads/presign-article", response: PresignArticleResponseSchema }),
+    presignArticleImage: endpoint({ method: "POST", path: "/uploads/presign-article", body: UploadArticleImageRequestSchema, response: UploadArticleImageResponseSchema }),
     delete: endpoint({ method: "DELETE", path: "/articles/:articleId", pathParams: articleIdParam, response: NoContentSchema }),
     deleteComment: endpoint({ method: "DELETE", path: "/articles/comments/:commentId", pathParams: commentIdParam, response: NoContentSchema })
     // TODO: 게시물 수정 기능
@@ -636,25 +718,26 @@ var apiContract = {
     list: endpoint({ method: "GET", path: "/recruits", query: RecruitListQuerySchema, response: RecruitListResponseSchema }),
     create: endpoint({ method: "POST", path: "/recruits", body: CreateRecruitRequestSchema, response: CreateRecruitResponseSchema }),
     join: endpoint({ method: "POST", path: "/recruits/:recruitId/join", pathParams: recruitIdParam, response: NoContentSchema }),
-    close: endpoint({ method: "PATCH", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema })
+    close: endpoint({ method: "POST", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema })
   },
   invitations: {
-    list: endpoint({ method: "GET", path: "/invitations", response: import_zod19.z.array(InvitationListItemResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/invitations", response: import_zod20.z.array(InvitationListItemResponseSchema) }),
     //  TODO: Invitation Response 정하기 detail: endpoint({ method: "GET", path: "/invitations/:invitationId", pathParams: invitationIdParam, response: InvitationItemDetailResponseSchema }),
-    send: endpoint({ method: "POST", path: "/invitations", body: CreateInvitationRequestSchema, response: SendInvitationResponseSchema }),
+    send: endpoint({ method: "POST", path: "/invitations/send", body: CreateInvitationRequestSchema, response: SendInvitationResponseSchema }),
     accept: endpoint({ method: "POST", path: "/invitations/:invitationId/accept", pathParams: invitationIdParam, response: AcceptInvitationResponseSchema }),
     reject: endpoint({ method: "POST", path: "/invitations/:invitationId/reject", pathParams: invitationIdParam, response: NoContentSchema })
   },
   plans: {
-    list: endpoint({ method: "GET", path: "/plans", query: PlanListQuerySchema, response: import_zod19.z.array(PlanResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/plans", query: PlanListQuerySchema, response: import_zod20.z.array(PlanResponseSchema) }),
     detail: endpoint({ method: "GET", path: "/plans/:planId", pathParams: planIdParam, response: PlanResponseSchema }),
     cancel: endpoint({ method: "PATCH", path: "/plans/:planId/cancel", pathParams: planIdParam, response: NoContentSchema })
   },
   friends: {
-    list: endpoint({ method: "GET", path: "/friends", response: import_zod19.z.array(FriendListItemResponseSchema) }),
-    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod19.z.array(FriendBlockItemResponseSchema) }),
-    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod19.z.array(FriendRequestItemResponseSchema) }),
-    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod19.z.array(FriendRequestItemResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/friends", response: import_zod20.z.array(FriendListItemResponseSchema) }),
+    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod20.z.array(FriendBlockItemResponseSchema) }),
+    search: endpoint({ method: "GET", path: "/friends/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
+    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
+    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
     sendRequest: endpoint({ method: "POST", path: "/friends/requests/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
     acceptRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/accept", pathParams: friendRequestIdParam, response: NoContentSchema }),
     rejectRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/reject", pathParams: friendRequestIdParam, response: NoContentSchema }),
@@ -664,52 +747,31 @@ var apiContract = {
     unfriend: endpoint({ method: "DELETE", path: "/friends/:memberId", pathParams: memberIdParam, response: NoContentSchema })
   },
   coupons: {
-    list: endpoint({ method: "GET", path: "/coupons", response: import_zod19.z.array(CouponResponseSchema) }),
-    use: endpoint({ method: "PATCH", path: "/coupons/:couponId/use", pathParams: couponIdParam, response: NoContentSchema })
+    list: endpoint({ method: "GET", path: "/coupons", response: import_zod20.z.array(CouponResponseSchema) }),
+    use: endpoint({ method: "POST", path: "/coupons/:couponId/use", pathParams: couponIdParam, response: NoContentSchema })
   },
   challenges: {
     status: endpoint({ method: "GET", path: "/challenges/status", response: ChallengeStatusResponseSchema }),
     claimReward: endpoint({ method: "POST", path: "/challenges/rewards", body: ClaimChallengeRewardRequestSchema, response: NoContentSchema })
   },
   referrals: {
-    list: endpoint({ method: "GET", path: "/referrals", response: import_zod19.z.array(ReferralItemResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/referrals", response: import_zod20.z.array(ReferralItemResponseSchema) }),
     create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
     redeem: endpoint({ method: "POST", path: "/referrals/redeem", body: RedeemReferralRequestSchema, response: NoContentSchema })
   },
+  notifications: {
+    list: endpoint({ method: "GET", path: "/notifications", response: import_zod20.z.array(MatchingNotificationSchema) }),
+    markRead: endpoint({ method: "PATCH", path: "/notifications/:notificationId/read", pathParams: notificationIdParam, response: MatchingNotificationSchema }),
+    delete: endpoint({ method: "DELETE", path: "/notifications/:notificationId", pathParams: notificationIdParam, response: NoContentSchema })
+  },
   room: {
-    //TODO: 방 입장 기능
+    access: endpoint({ method: "GET", path: "/rooms/:roomId/access", pathParams: roomIdParam, response: RoomAccessResponseSchema })
   },
   health: {
-    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod19.z.string() })
+    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod20.z.string() })
   }
 };
 
-// src/domain/common/schema/envelope.schema.ts
-var import_zod20 = require("zod");
-var NoContentSchema = import_zod20.z.null();
-var ApiSuccessSchema = (data) => import_zod20.z.object({
-  success: import_zod20.z.literal(true),
-  code: import_zod20.z.number().int(),
-  message: import_zod20.z.string(),
-  data
-});
-var ApiFailureSchema = import_zod20.z.object({
-  success: import_zod20.z.literal(false),
-  status: import_zod20.z.number().int(),
-  code: import_zod20.z.string(),
-  message: import_zod20.z.string()
-});
-var ApiResponseSchema = (data) => import_zod20.z.union([ApiSuccessSchema(data), ApiFailureSchema]);
-var CreatedEntityIdResponseSchema = import_zod20.z.discriminatedUnion("entity", [
-  import_zod20.z.object({ entity: import_zod20.z.literal("article"), id: ArticleIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("comment"), id: CommentIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("recruit"), id: RecruitIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("invitation"), id: InvitationIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("subscription"), id: SubscriptionIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("coupon"), id: CouponIdSchema }),
-  import_zod20.z.object({ entity: import_zod20.z.literal("plan"), id: PlanIdSchema })
-]);
-
 // src/domain/common/contracts/envelope.ts
 var makeApiResponseSchema = ApiResponseSchema;
 var makeApiSuccessSchema = ApiSuccessSchema;