@kimdaegyu/babmukdang-shared 1.1.0 → 1.1.3

package/dist/domain/common/index.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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/common/index.ts
@@ -27,7 +37,9 @@ __export(common_exports, {
   CommentIdSchema: () => CommentIdSchema,
   CouponIdSchema: () => CouponIdSchema,
   CreatedEntityIdResponseSchema: () => CreatedEntityIdResponseSchema,
-  CreatedIdResponseSchema: () => CreatedIdResponseSchema,
+  FoodCodeSchema: () => FoodCodeSchema,
+  FoodLabelSchema: () => FoodLabelSchema,
+  FoodSchema: () => FoodSchema,
   FriendRequestIdSchema: () => FriendRequestIdSchema,
   ISODateStringSchema: () => ISODateStringSchema,
   ISODateTimeStringSchema: () => ISODateTimeStringSchema,
@@ -38,16 +50,16 @@ __export(common_exports, {
   NoParamsSchema: () => NoParamsSchema,
   NoQuerySchema: () => NoQuerySchema,
   NonEmptyStringIdSchema: () => NonEmptyStringIdSchema,
-  PageRequestSchema: () => PageRequestSchema,
+  PageMetaSchema: () => PageMetaSchema,
+  PageQuerySchema: () => PageQuerySchema,
   PageResponseSchema: () => PageResponseSchema,
-  PageableObjectSchema: () => PageableObjectSchema,
   PlanIdSchema: () => PlanIdSchema,
   PositiveIntIdSchema: () => PositiveIntIdSchema,
   RecruitIdSchema: () => RecruitIdSchema,
   ReferralCodeSchema: () => ReferralCodeSchema,
   RestaurantIdSchema: () => RestaurantIdSchema,
   RoomIdSchema: () => RoomIdSchema,
-  SortObjectSchema: () => SortObjectSchema,
+  SortDirectionSchema: () => SortDirectionSchema,
   SubscriptionIdSchema: () => SubscriptionIdSchema,
   TimeHHmmStringSchema: () => TimeHHmmStringSchema,
   UserIdSchema: () => UserIdSchema,
@@ -56,19 +68,25 @@ __export(common_exports, {
   makeApiResponseSchema: () => makeApiResponseSchema,
   makeApiSuccessSchema: () => makeApiSuccessSchema,
   toArticleId: () => toArticleId,
+  toCommentId: () => toCommentId,
+  toCouponId: () => toCouponId,
+  toFriendRequestId: () => toFriendRequestId,
   toInvitationId: () => toInvitationId,
   toMemberId: () => toMemberId,
+  toPlanId: () => toPlanId,
   toRecruitId: () => toRecruitId,
+  toReferralCode: () => toReferralCode,
   toRestaurantId: () => toRestaurantId,
-  toRoomId: () => toRoomId
+  toRoomId: () => toRoomId,
+  toSubscriptionId: () => toSubscriptionId
 });
 module.exports = __toCommonJS(common_exports);
 
 // src/domain/common/contracts/api.ts
-var import_zod20 = require("zod");
+var import_zod19 = require("zod");
 
-// src/domain/article/schema/article.schema.ts
-var import_zod6 = require("zod");
+// src/domain/article/article.schema.ts
+var import_zod7 = require("zod");
 
 // src/domain/common/schema/date.schema.ts
 var import_zod = require("zod");
@@ -94,365 +112,289 @@ 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/common/schema/pagination.schema.ts
 var import_zod3 = require("zod");
-var PageRequestSchema = import_zod3.z.object({
-  page: import_zod3.z.number().int().min(0).default(0),
-  size: import_zod3.z.number().int().min(1).max(100).default(20)
-});
-var SortObjectSchema = import_zod3.z.object({
-  empty: import_zod3.z.boolean(),
-  sorted: import_zod3.z.boolean(),
-  unsorted: import_zod3.z.boolean()
-});
-var PageableObjectSchema = import_zod3.z.object({
-  offset: import_zod3.z.number().int().min(0),
-  sort: SortObjectSchema,
-  paged: import_zod3.z.boolean(),
-  pageNumber: import_zod3.z.number().int().min(0),
-  pageSize: import_zod3.z.number().int().min(1),
-  unpaged: import_zod3.z.boolean()
+var PageQuerySchema = import_zod3.z.object({
+  page: import_zod3.z.number().int().min(0).optional().default(0),
+  size: import_zod3.z.number().int().min(1).max(100).optional().default(20)
+});
+var PageMetaSchema = import_zod3.z.object({
+  page: import_zod3.z.number().int().min(0),
+  size: import_zod3.z.number().int().min(1),
+  totalItems: import_zod3.z.number().int().min(0),
+  totalPages: import_zod3.z.number().int().min(0),
+  hasNext: import_zod3.z.boolean(),
+  hasPrevious: import_zod3.z.boolean()
 });
 var PageResponseSchema = (item) => import_zod3.z.object({
-  totalElements: import_zod3.z.number().int().min(0),
-  totalPages: import_zod3.z.number().int().min(0),
-  first: import_zod3.z.boolean(),
-  size: import_zod3.z.number().int().min(0),
-  content: import_zod3.z.array(item),
-  number: import_zod3.z.number().int().min(0),
-  sort: SortObjectSchema,
-  numberOfElements: import_zod3.z.number().int().min(0),
-  pageable: PageableObjectSchema,
-  last: import_zod3.z.boolean(),
-  empty: import_zod3.z.boolean()
+  items: import_zod3.z.array(item),
+  meta: PageMetaSchema
+});
+var SortDirectionSchema = import_zod3.z.enum(["asc", "desc"]);
+
+// src/domain/member/member.schema.ts
+var import_zod5 = require("zod");
+
+// src/domain/common/contracts/upload.ts
+var import_zod4 = __toESM(require("zod"), 1);
+var PresignUploadResponseSchema = import_zod4.default.object({
+  key: import_zod4.default.string(),
+  putUrl: import_zod4.default.string().url(),
+  cdnUrl: import_zod4.default.string().url()
 });
 
-// src/domain/member/schema/member.schema.ts
-var import_zod4 = require("zod");
-var MemberRoleSchema = import_zod4.z.enum(["USER", "ADMIN"]);
-var MemberCoreSchema = import_zod4.z.object({
+// src/domain/member/member.schema.ts
+var MemberRoleSchema = import_zod5.z.enum(["USER", "ADMIN"]);
+var MemberCoreSchema = import_zod5.z.object({
   memberId: MemberIdSchema,
-  username: import_zod4.z.string().min(1).max(50),
-  profileImageUrl: import_zod4.z.string().url().nullable()
+  username: import_zod5.z.string().min(1).max(50),
+  profileImageUrl: import_zod5.z.string().url().nullable().optional()
 });
+var PresignProfileResponseSchema = PresignUploadResponseSchema.extend({});
 var MemberResponseSchema = MemberCoreSchema.pick({
   memberId: true,
   username: true,
   profileImageUrl: true
 });
-var MemberSummaryResponseSchema = MemberCoreSchema.extend({
-  friends: 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)
-});
-var AuthPrincipalSchema = import_zod4.z.object({
-  memberId: MemberIdSchema,
-  role: MemberRoleSchema
-});
-var ProfilePreferenceItemSchema = import_zod4.z.object({
-  code: import_zod4.z.string(),
-  label: import_zod4.z.string()
-});
-var ProfileDetailResponseSchema = MemberCoreSchema.extend({
-  bio: import_zod4.z.string().nullable(),
-  planCount: import_zod4.z.number().int().min(0),
-  likes: import_zod4.z.array(ProfilePreferenceItemSchema),
-  dislikes: import_zod4.z.array(ProfilePreferenceItemSchema),
-  allergies: import_zod4.z.array(ProfilePreferenceItemSchema)
-});
-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 OnboardingPreferenceRequestSchema = import_zod4.z.object({
-  likedCodes: import_zod4.z.array(import_zod4.z.string()),
-  dislikedCodes: import_zod4.z.array(import_zod4.z.string()),
-  allergyCodes: import_zod4.z.array(import_zod4.z.string())
-});
-var OnboardingRequestSchema = UpdateProfileRequestSchema.merge(
-  OnboardingPreferenceRequestSchema
+var MemberSearchQuerySchema = import_zod5.z.object({
+  email: import_zod5.z.string().email().optional(),
+  username: import_zod5.z.string().optional()
+});
+var MemberSerachResponseSchema = import_zod5.z.array(MemberCoreSchema);
+var MemberDetailSchema = MemberCoreSchema.extend({
+  bio: import_zod5.z.string().nullable(),
+  friendConunt: import_zod5.z.number().int().min(0).default(0),
+  completedPlans: import_zod5.z.number().int().min(0).default(0),
+  uncompletedPlans: import_zod5.z.number().int().min(0).default(0)
+});
+var FoodPreferenceItemSchema = FoodSchema.extend({});
+var MemberFoodPreferenceSchema = import_zod5.z.object({
+  liked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  disliked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  allergy: import_zod5.z.array(FoodPreferenceItemSchema).optional()
+});
+var ProfileDetailResponseSchema = MemberDetailSchema;
+var UpdateProfileRequestSchema = import_zod5.z.object({
+  username: import_zod5.z.string().min(1).max(50),
+  profileImageUrl: import_zod5.z.string().url().nullable(),
+  bio: import_zod5.z.string().max(500).nullable()
+});
+var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
+var CreateProfileRequestSchema = UpdateProfileRequestSchema.merge(
+  UpdatePreferenceRequestSchema
 );
-var PreferenceMetaResponseSchema = import_zod4.z.object({
-  onboardedAt: ISODateTimeStringSchema.nullable(),
-  lastUpdatedAt: ISODateTimeStringSchema.nullable(),
-  revision: import_zod4.z.number().int().min(0)
-});
 
-// src/domain/restaurant/schema/restaurant.schema.ts
-var import_zod5 = require("zod");
-var RestaurantSchema = import_zod5.z.object({
+// src/domain/restaurant/restaurant.schema.ts
+var import_zod6 = require("zod");
+var RestaurantSchema = import_zod6.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({
+  placeName: import_zod6.z.string(),
+  categoryName: import_zod6.z.string(),
+  categoryGroupName: import_zod6.z.string(),
+  distance: import_zod6.z.string().optional(),
+  roadAddressName: import_zod6.z.string(),
+  addressName: import_zod6.z.string(),
+  phone: import_zod6.z.string().nullable(),
+  placeUrl: import_zod6.z.string().url().nullable(),
+  lat: import_zod6.z.number(),
+  lng: import_zod6.z.number()
+});
+var KakaoPlaceRawSchema = import_zod6.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()
+  place_name: import_zod6.z.string(),
+  category_name: import_zod6.z.string(),
+  category_group_name: import_zod6.z.string(),
+  distance: import_zod6.z.string(),
+  road_address_name: import_zod6.z.string(),
+  address_name: import_zod6.z.string(),
+  phone: import_zod6.z.string(),
+  place_url: import_zod6.z.string().url().optional(),
+  lat: import_zod6.z.number(),
+  lng: import_zod6.z.number()
 });
 
-// src/domain/article/schema/article.schema.ts
-var FoodAnalysisResultSchema = import_zod6.z.object({
-  code: import_zod6.z.string(),
-  label: import_zod6.z.string(),
-  confidence: import_zod6.z.number().min(0).max(1),
+// src/domain/article/article.schema.ts
+var ArticleSortBySchema = import_zod7.z.enum(["createdAt", "likeCount", "commentCount"]);
+var ArticleListQuerySchema = PageQuerySchema.extend({
+  sortBy: ArticleSortBySchema.optional().default("createdAt"),
+  direction: SortDirectionSchema.optional().default("desc")
+});
+var PresignArticleResponseSchema = PresignUploadResponseSchema.extend({});
+var FoodAnalysisResultSchema = FoodSchema.extend({
+  confidence: import_zod7.z.number().min(0).max(1),
   tsUtc: ISODateTimeStringSchema.optional()
 });
-var ArticlePostRequestSchema = import_zod6.z.object({
-  imageUrl: import_zod6.z.string().url(),
+var CreateArticleRequestSchema = import_zod7.z.object({
+  imageUrl: import_zod7.z.string().url(),
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
-  taggedMemberIds: import_zod6.z.array(MemberIdSchema).default([]),
+  taggedMemberIds: import_zod7.z.array(MemberIdSchema).default([]),
   foodAnalysis: FoodAnalysisResultSchema.optional()
 });
-var CreateArticleResponseSchema = import_zod6.z.object({
-  articleId: ArticleIdSchema
-});
-var CommentPostRequestSchema = import_zod6.z.object({
-  content: import_zod6.z.string().min(1).max(500),
+var CreateCommentRequestSchema = import_zod7.z.object({
+  content: import_zod7.z.string().min(1).max(500),
   parentCommentId: CommentIdSchema.nullish()
 });
-var CreateCommentResponseSchema = import_zod6.z.object({
-  commentId: CommentIdSchema
-});
-var CommentResponseSchema = import_zod6.z.object({
+var ArticleCommentSchema = import_zod7.z.object({
   commentId: CommentIdSchema,
-  author: MemberResponseSchema,
+  author: MemberCoreSchema,
   parentCommentId: CommentIdSchema.nullable(),
-  content: import_zod6.z.string(),
+  content: import_zod7.z.string(),
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
-var ArticleCoreSchema = import_zod6.z.object({
+var ArticleCoreSchema = import_zod7.z.object({
   articleId: ArticleIdSchema,
-  author: MemberResponseSchema,
-  imageUrl: import_zod6.z.string().url(),
+  author: MemberCoreSchema,
+  imageUrl: import_zod7.z.string().url(),
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  taggedMembers: import_zod6.z.array(MemberResponseSchema)
+  taggedMembers: import_zod7.z.array(MemberCoreSchema)
 });
 var ArticleSummaryResponseSchema = ArticleCoreSchema.extend({
-  likeCount: import_zod6.z.number().int().min(0),
-  commentCount: import_zod6.z.number().int().min(0),
-  likedByMe: import_zod6.z.boolean()
+  likeCount: import_zod7.z.number().int().min(0),
+  commentCount: import_zod7.z.number().int().min(0),
+  likedByMe: import_zod7.z.boolean()
 });
 var ArticleDetailResponseSchema = ArticleSummaryResponseSchema.extend({
-  comments: import_zod6.z.array(CommentResponseSchema).optional()
-});
-var PageArticleSummaryResponseSchema = PageResponseSchema(
-  ArticleSummaryResponseSchema
-);
-var PresignUploadResponseSchema = import_zod6.z.object({
-  key: import_zod6.z.string(),
-  putUrl: import_zod6.z.string().url(),
-  cdnUrl: import_zod6.z.string().url()
+  comments: import_zod7.z.array(ArticleCommentSchema).optional()
 });
+var PageArticleSummaryResponseSchema = PageResponseSchema(ArticleSummaryResponseSchema);
 
-// src/domain/auth/schema/auth.schema.ts
-var import_zod7 = require("zod");
-var TokenResponseSchema = import_zod7.z.object({
-  accessToken: import_zod7.z.string().min(1),
-  accessTokenMaxAge: import_zod7.z.number().int().positive()
+// 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()
 });
-var LoginRequestSchema = import_zod7.z.object({
-  email: import_zod7.z.string().email(),
-  password: import_zod7.z.string().min(1)
+var LoginRequestSchema = import_zod8.z.object({
+  email: import_zod8.z.string().email(),
+  password: import_zod8.z.string().min(1)
 });
-var SignupRequestSchema = import_zod7.z.object({
-  email: import_zod7.z.string().email(),
-  password: import_zod7.z.string().min(8),
-  username: import_zod7.z.string().min(1).max(50),
-  profileImageUrl: import_zod7.z.string().url().nullable().optional()
+var SignupRequestSchema = import_zod8.z.object({
+  email: import_zod8.z.string().email(),
+  password: import_zod8.z.string().min(8),
+  username: import_zod8.z.string().min(1).max(50),
+  profileImageUrl: import_zod8.z.string().url().nullable().optional()
 });
-var SignupResponseSchema = import_zod7.z.object({
-  member: MemberResponseSchema
+var SignupResponseSchema = import_zod8.z.object({
+  member: MemberCoreSchema
 });
 
-// src/domain/challenge/schema/challenge.schema.ts
-var import_zod8 = require("zod");
-var RewardTypeSchema = import_zod8.z.enum(["WEEK", "MONTH"]);
-var WeekProgressSchema = import_zod8.z.object({
-  days: import_zod8.z.array(import_zod8.z.boolean()),
-  completed: import_zod8.z.number().int().min(0),
-  goal: import_zod8.z.number().int().positive()
-});
-var MonthProgressSchema = import_zod8.z.object({
-  count: import_zod8.z.number().int().min(0),
-  goal: import_zod8.z.number().int().positive()
-});
-var ChallengeStatusResponseSchema = import_zod8.z.object({
-  week: WeekProgressSchema,
-  month: MonthProgressSchema,
-  weekRewardAvailable: import_zod8.z.boolean(),
-  monthRewardAvailable: import_zod8.z.boolean()
-});
-var ClaimChallengeRewardRequestSchema = import_zod8.z.object({
-  type: RewardTypeSchema
+// src/domain/promotion/challenge.schema.ts
+var import_zod9 = require("zod");
+var RewardTypeSchema = import_zod9.z.enum(["WEEK", "MONTH"]);
+var WeekProgressSchema = import_zod9.z.object({
+  days: import_zod9.z.array(import_zod9.z.boolean()),
+  completed: import_zod9.z.number().int().min(0),
+  goal: import_zod9.z.number().int().positive()
 });
-var ClaimChallengeRewardResponseSchema = import_zod8.z.object({
-  rewardType: RewardTypeSchema,
-  claimed: import_zod8.z.boolean()
+var MonthProgressSchema = import_zod9.z.object({
+  count: import_zod9.z.number().int().min(0),
+  goal: import_zod9.z.number().int().positive()
 });
-
-// src/domain/coupon/schema/coupon.schema.ts
-var import_zod9 = require("zod");
-var CouponTypeSchema = import_zod9.z.enum(["DISCOUNT", "SERVICE"]);
-var CouponStatusSchema = import_zod9.z.enum(["UNUSED", "USED"]);
-var CouponResponseSchema = import_zod9.z.object({
-  couponId: CouponIdSchema,
-  title: import_zod9.z.string(),
-  shopName: import_zod9.z.string(),
-  type: CouponTypeSchema,
-  condition: import_zod9.z.string(),
-  expiresAt: ISODateStringSchema,
-  used: import_zod9.z.boolean(),
-  thumbnailUrl: import_zod9.z.string().url()
+var ChallengeStatusResponseSchema = import_zod9.z.object({
+  count: import_zod9.z.number().int().min(0)
 });
-
-// src/domain/common/schema/envelope.schema.ts
-var import_zod10 = require("zod");
-var NoContentSchema = import_zod10.z.null();
-var ApiSuccessSchema = (data) => import_zod10.z.object({
-  success: import_zod10.z.literal(true),
-  code: import_zod10.z.number().int(),
-  message: import_zod10.z.string(),
-  data
+var ClaimChallengeRewardRequestSchema = import_zod9.z.object({
+  type: RewardTypeSchema
 });
-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 CreatedIdResponseSchema = import_zod10.z.object({
-  id: import_zod10.z.number().int().positive()
-});
-var CreatedEntityIdResponseSchema = import_zod10.z.object({
-  entity: import_zod10.z.enum([
-    "article",
-    "comment",
-    "recruit",
-    "invitation",
-    "subscription",
-    "coupon",
-    "plan"
-  ]),
-  id: import_zod10.z.number().int().positive()
+var ClaimChallengeRewardResponseSchema = import_zod9.z.object({
+  rewardType: RewardTypeSchema,
+  claimed: import_zod9.z.boolean()
 });
 
-// src/domain/friend/schema/friend.schema.ts
-var import_zod11 = require("zod");
-var FriendMealFilterSchema = import_zod11.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
-var FriendRequestStatusSchema = import_zod11.z.enum([
-  "PENDING",
-  "ACCEPTED",
-  "REJECTED",
-  "CANCELED"
-]);
-var FriendMealItemResponseSchema = MemberResponseSchema.extend({
-  hungry: import_zod11.z.boolean(),
-  label: import_zod11.z.string()
-});
-var FriendListItemResponseSchema = MemberResponseSchema.extend({
+// src/domain/friend/friend.schema.ts
+var import_zod10 = require("zod");
+var FriendRequestStatusSchema = import_zod10.z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
+var FriendListItemResponseSchema = MemberCoreSchema.extend({
   friendSince: ISODateTimeStringSchema
 });
-var FriendBlockItemResponseSchema = MemberResponseSchema.extend({
+var FriendBlockItemResponseSchema = MemberCoreSchema.extend({
   blockedAt: ISODateTimeStringSchema
 });
-var FriendRequestMemberSchema = MemberResponseSchema;
-var FriendRequestItemResponseSchema = import_zod11.z.object({
+var FriendRequestMemberSchema = MemberCoreSchema;
+var FriendRequestItemResponseSchema = import_zod10.z.object({
   requestId: FriendRequestIdSchema,
   requester: FriendRequestMemberSchema,
   recipient: FriendRequestMemberSchema,
   status: FriendRequestStatusSchema,
   requestedAt: ISODateTimeStringSchema
 });
-var FriendActionRequestSchema = import_zod11.z.object({
-  memberId: MemberIdSchema
-});
 
-// src/domain/invitation/schema/invitation.schema.ts
-var import_zod12 = require("zod");
-var InvitationPostRequestSchema = import_zod12.z.object({
+// src/domain/invitation/invitation.schema.ts
+var import_zod11 = require("zod");
+var CreateInvitationRequestSchema = import_zod11.z.object({
   inviteeId: MemberIdSchema,
-  message: import_zod12.z.string().min(1).max(500)
+  message: import_zod11.z.string().min(1).max(500)
 });
-var InvitationListItemResponseSchema = import_zod12.z.object({
+var InvitationListItemResponseSchema = import_zod11.z.object({
   invitationId: InvitationIdSchema,
-  inviterName: import_zod12.z.string(),
-  inviterProfileImageUrl: import_zod12.z.string().url().nullable().optional()
+  inviterName: import_zod11.z.string(),
+  inviterProfileImageUrl: import_zod11.z.string().url().nullable().optional()
 });
-var SendInvitationResponseSchema = import_zod12.z.object({
+var SendInvitationResponseSchema = import_zod11.z.object({
   invitationId: InvitationIdSchema
 });
-var AcceptInvitationResponseSchema = import_zod12.z.object({
+var AcceptInvitationResponseSchema = import_zod11.z.object({
   invitationId: InvitationIdSchema,
-  room: import_zod12.z.object({
-    type: import_zod12.z.literal("invitation"),
+  room: import_zod11.z.object({
+    type: import_zod11.z.literal("invitation"),
     roomId: RoomIdSchema
   })
 });
-var RejectInvitationResponseSchema = NoContentSchema;
 
-// src/domain/meal/schema/meal.schema.ts
-var import_zod13 = require("zod");
-var MealStatusSchema = import_zod13.z.enum(["FED", "FASTING"]);
-var MealStatusActionSchema = import_zod13.z.enum(["ATE_NOW", "SET_OFF"]);
-var UpdateMealStatusRequestSchema = import_zod13.z.object({
-  action: MealStatusActionSchema
-});
-var MealStatusResponseSchema = import_zod13.z.object({
-  status: MealStatusSchema,
-  lastMealAt: ISODateTimeStringSchema.nullable(),
-  fastingMinutes: import_zod13.z.number().int().min(0),
-  fastingHours: import_zod13.z.number().min(0),
-  secondsToAutoOff: import_zod13.z.number().int().min(0)
+// 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(),
+  updatedAt: ISODateStringSchema,
+  secondsToAutoOff: import_zod12.z.number().int().min(0)
+});
+var MealStatusActionSchema = import_zod12.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
+var UpdateMealStatusRequestSchema = import_zod12.z.object({
+  action: MealStatusActionSchema.optional().default("SET_MANNUALY")
+});
+var MealStatusSchema = import_zod12.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
+var FriendMealQuerySchema = import_zod12.z.object({
+  status: MealStatusSchema.optional().default("ALL")
+});
+var FriendMealItemResponseSchema = MemberCoreSchema.extend({
+  hungry: import_zod12.z.boolean(),
+  label: import_zod12.z.string(),
+  updatedAt: ISODateStringSchema
 });
 
-// src/domain/plan/schema/plan.schema.ts
-var import_zod15 = require("zod");
+// src/domain/plan/plan.schema.ts
+var import_zod14 = require("zod");
 
 // src/domain/room/schema/room.schema.ts
-var import_zod14 = require("zod");
-var MenuCodeSchema = import_zod14.z.string().min(1).brand();
-var LocationIdSchema = import_zod14.z.string().min(1).brand();
-var MenuSchema = import_zod14.z.object({
-  code: MenuCodeSchema,
-  label: import_zod14.z.string()
-});
-var LocationCandidateSchema = import_zod14.z.object({
+var import_zod13 = require("zod");
+var MenuCodeSchema = FoodCodeSchema;
+var LocationIdSchema = import_zod13.z.string().min(1).brand();
+var MenuSchema = FoodSchema.extend({});
+var LocationCandidateSchema = import_zod13.z.object({
   locationId: LocationIdSchema,
-  placeName: import_zod14.z.string(),
-  lat: import_zod14.z.number(),
-  lng: import_zod14.z.number(),
-  address: import_zod14.z.string()
+  placeName: import_zod13.z.string(),
+  lat: import_zod13.z.number(),
+  lng: import_zod13.z.number(),
+  address: import_zod13.z.string()
 });
-var ParticipantSchema = MemberResponseSchema.extend({
-  ready: import_zod14.z.boolean()
+var ParticipantSchema = MemberCoreSchema.extend({
+  ready: import_zod13.z.boolean()
 });
-var RecruitRoomStageSchema = import_zod14.z.enum([
+var RecruitRoomStageSchema = import_zod13.z.enum([
   "waiting",
   "location",
   "location-vote",
@@ -461,7 +403,7 @@ var RecruitRoomStageSchema = import_zod14.z.enum([
   "restaurant",
   "finish"
 ]);
-var InvitationRoomStageSchema = import_zod14.z.enum([
+var InvitationRoomStageSchema = import_zod13.z.enum([
   "waiting",
   "date",
   "time",
@@ -472,153 +414,163 @@ var InvitationRoomStageSchema = import_zod14.z.enum([
   "restaurant",
   "finish"
 ]);
-var ReadyStateRequestSchema = import_zod14.z.object({
-  isReady: import_zod14.z.boolean()
-});
-var ChatMessageRequestSchema = import_zod14.z.object({
-  message: import_zod14.z.string().min(1).max(500)
-});
-var VoteLocationRequestSchema = import_zod14.z.object({ locationId: LocationIdSchema });
-var ExcludeMenuRequestSchema = import_zod14.z.object({ menu: MenuSchema });
-var PickMenuRequestSchema = import_zod14.z.object({ menuCode: MenuCodeSchema });
-var PickRestaurantRequestSchema = import_zod14.z.object({ restaurantId: RestaurantIdSchema });
-var PickTimesRequestSchema = import_zod14.z.object({ times: import_zod14.z.array(import_zod14.z.string().min(1)).min(1) });
-var PickDateRequestSchema = import_zod14.z.object({ dates: import_zod14.z.array(ISODateStringSchema).min(1) });
-var RoomAssignedResponseSchema = import_zod14.z.object({
+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({
   roomId: RoomIdSchema
 });
-var RoomSocketErrorSchema = import_zod14.z.object({
-  code: import_zod14.z.string(),
-  message: import_zod14.z.string()
+var RoomSocketErrorSchema = import_zod13.z.object({
+  code: import_zod13.z.string(),
+  message: import_zod13.z.string()
 });
-var ChatMessageResponseSchema = import_zod14.z.object({
-  messageId: import_zod14.z.string(),
-  user: MemberResponseSchema,
-  message: import_zod14.z.string(),
+var ChatMessageResponseSchema = import_zod13.z.object({
+  messageId: import_zod13.z.string(),
+  user: MemberCoreSchema,
+  message: import_zod13.z.string(),
   createdAt: ISODateTimeStringSchema
 });
-var ReadyStateChangedSchema = import_zod14.z.object({
-  readyCount: import_zod14.z.number().int().min(0),
-  participantCount: import_zod14.z.number().int().min(0)
+var ReadyStateChangedSchema = import_zod13.z.object({
+  readyCount: import_zod13.z.number().int().min(0),
+  participantCount: import_zod13.z.number().int().min(0)
 });
-var FinalStateSchema = import_zod14.z.object({
+var FinalStateSchema = import_zod13.z.object({
   location: LocationCandidateSchema.optional(),
-  excludeMenu: import_zod14.z.array(MenuSchema).optional(),
+  excludeMenu: import_zod13.z.array(MenuSchema).optional(),
   menu: MenuSchema.optional(),
   restaurant: RestaurantSchema.optional(),
-  time: import_zod14.z.string().optional(),
+  time: import_zod13.z.string().optional(),
   date: ISODateStringSchema.optional()
 });
-var RoomInitialStateSchema = import_zod14.z.object({
-  participants: import_zod14.z.array(ParticipantSchema),
-  chat: import_zod14.z.array(ChatMessageResponseSchema),
+var RoomInitialStateSchema = import_zod13.z.object({
+  participants: import_zod13.z.array(ParticipantSchema),
+  chat: import_zod13.z.array(ChatMessageResponseSchema),
   final: FinalStateSchema
 });
-var PhaseDataBroadcastSchema = import_zod14.z.object({
-  phase: import_zod14.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
-  data: import_zod14.z.unknown()
+var PhaseDataBroadcastSchema = import_zod13.z.object({
+  phase: import_zod13.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
+  data: import_zod13.z.unknown()
 });
-var TimePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, times: import_zod14.z.array(import_zod14.z.string()) })
+var TimePicksUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ memberId: MemberIdSchema, times: import_zod13.z.array(import_zod13.z.string()) })
 );
-var DatePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, dates: import_zod14.z.array(ISODateStringSchema) })
+var DatePicksUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ memberId: MemberIdSchema, dates: import_zod13.z.array(ISODateStringSchema) })
 );
-var LocationCandidateAddUpdateResponseSchema = import_zod14.z.array(
+var LocationCandidateAddUpdateResponseSchema = import_zod13.z.array(
   LocationCandidateSchema.extend({ authorMemberId: MemberIdSchema })
 );
-var LocationCandidateVoteUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ locationId: LocationIdSchema, votes: import_zod14.z.array(MemberIdSchema) })
+var LocationCandidateVoteUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ locationId: LocationIdSchema, votes: import_zod13.z.array(MemberIdSchema) })
 );
-var ExcludeMenuUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, exclusions: import_zod14.z.array(MenuSchema) })
+var ExcludeMenuUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ memberId: MemberIdSchema, exclusions: import_zod13.z.array(MenuSchema) })
 );
-var MenuPickUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
+var MenuPickUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ menuCode: MenuCodeSchema, 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 RestaurantPickUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod13.z.array(MemberIdSchema) })
 );
 
-// src/domain/plan/schema/plan.schema.ts
-var PlanStatusSchema = import_zod15.z.enum(["PLANNING", "COMPLETED"]);
-var PlanTypeSchema = import_zod15.z.enum(["RECRUIT", "INVITATION"]);
-var CreatePlanRequestSchema = import_zod15.z.object({
-  meetingDate: ISODateStringSchema,
-  meetingTime: TimeHHmmStringSchema
-});
-var PlanResponseSchema = import_zod15.z.object({
+// 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({
   planId: PlanIdSchema,
   meetingAt: ISODateTimeStringSchema,
   location: LocationCandidateSchema.nullable(),
   restaurant: RestaurantSchema.nullable(),
-  author: MemberResponseSchema.nullable(),
-  participants: import_zod15.z.array(MemberResponseSchema),
+  author: MemberCoreSchema,
+  participants: import_zod14.z.array(MemberCoreSchema),
   status: PlanStatusSchema,
   type: PlanTypeSchema,
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
+var PlanListQuerySchema = import_zod14.z.object({});
 
-// src/domain/preference/schema/preference.schema.ts
-var import_zod16 = require("zod");
-var FoodPreferenceTypeSchema = import_zod16.z.enum(["LIKE", "DISLIKE", "ALLERGY"]);
-var FoodPreferenceResponseSchema = import_zod16.z.object({
-  id: import_zod16.z.number().int().positive(),
-  memberId: MemberIdSchema,
-  foodCode: import_zod16.z.string(),
-  type: FoodPreferenceTypeSchema,
-  createdAt: ISODateTimeStringSchema,
-  updatedAt: ISODateTimeStringSchema
-});
-
-// src/domain/recruit/schema/recruit.schema.ts
-var import_zod17 = require("zod");
-var RecruitStatusSchema = import_zod17.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
-var RecruitRequestSchema = import_zod17.z.object({
-  targetCount: import_zod17.z.number().int().min(2),
+// src/domain/recruit/recruit.schema.ts
+var import_zod15 = require("zod");
+var RecruitStatusSchema = import_zod15.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
+var RecruitParticipantSchema = MemberCoreSchema.extend({});
+var RecruitSortBySchema = import_zod15.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),
   meetingAt: ISODateTimeStringSchema,
-  location: import_zod17.z.string().min(1),
-  message: import_zod17.z.string().max(500)
-});
-var RecruitParticipantSchema = MemberResponseSchema.extend({});
-var RecruitResponseSchema = RecruitRequestSchema.extend({
+  location: import_zod15.z.string().min(1),
+  message: import_zod15.z.string().max(500),
   recruitId: RecruitIdSchema,
   status: RecruitStatusSchema,
   createdAt: ISODateTimeStringSchema,
   expiredAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema,
-  author: MemberResponseSchema,
-  participants: import_zod17.z.array(RecruitParticipantSchema)
+  author: MemberCoreSchema,
+  participants: import_zod15.z.array(RecruitParticipantSchema)
 });
-var CreateRecruitResponseSchema = import_zod17.z.object({
+var RecruitListResponseSchema = import_zod15.z.array(RecruitResponseSchema);
+var CreateRecruitRequestSchema = import_zod15.z.object({
+  targetCount: import_zod15.z.number().int().min(2),
+  meetingAt: ISODateTimeStringSchema,
+  location: import_zod15.z.string().min(1),
+  message: import_zod15.z.string().max(500)
+});
+var CreateRecruitResponseSchema = import_zod15.z.object({
   recruitId: RecruitIdSchema
 });
 
-// src/domain/referral/schema/referral.schema.ts
-var import_zod18 = require("zod");
-var ReferralCreateResponseSchema = import_zod18.z.object({
+// src/domain/promotion/referral.schema.ts
+var import_zod16 = require("zod");
+var ReferralCreateResponseSchema = import_zod16.z.object({
   code: ReferralCodeSchema,
-  link: import_zod18.z.string().url(),
+  link: import_zod16.z.string().url(),
   expiresAt: ISODateTimeStringSchema
 });
-var ReferralItemResponseSchema = import_zod18.z.object({
+var ReferralItemResponseSchema = import_zod16.z.object({
   code: ReferralCodeSchema,
   createdAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  used: import_zod18.z.boolean(),
+  used: import_zod16.z.boolean(),
   usedByMemberId: MemberIdSchema.nullable(),
-  usedByUsername: import_zod18.z.string().nullable()
+  usedByUsername: import_zod16.z.string().nullable()
 });
-var RedeemReferralRequestSchema = import_zod18.z.object({
+var RedeemReferralRequestSchema = import_zod16.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({
+  couponId: CouponIdSchema,
+  title: import_zod17.z.string(),
+  shopName: import_zod17.z.string(),
+  type: CouponTypeSchema,
+  condition: import_zod17.z.string(),
+  expiresAt: ISODateStringSchema,
+  used: import_zod17.z.boolean(),
+  thumbnailUrl: import_zod17.z.string().url()
+});
+
 // src/domain/common/contracts/endpoint.ts
-var import_zod19 = require("zod");
-var NoBodySchema = import_zod19.z.undefined();
-var NoQuerySchema = import_zod19.z.undefined();
-var NoParamsSchema = import_zod19.z.undefined();
+var import_zod18 = require("zod");
+var NoBodySchema = import_zod18.z.undefined();
+var NoQuerySchema = import_zod18.z.undefined();
+var NoParamsSchema = import_zod18.z.undefined();
 var endpoint = (contract) => ({
   method: contract.method,
   path: contract.path,
@@ -629,89 +581,128 @@ var endpoint = (contract) => ({
 });
 
 // src/domain/common/contracts/api.ts
-var memberIdParam = import_zod20.z.object({ memberId: MemberIdSchema });
-var articleIdParam = import_zod20.z.object({ articleId: ArticleIdSchema });
-var commentIdParam = import_zod20.z.object({ commentId: CommentIdSchema });
-var recruitIdParam = import_zod20.z.object({ recruitId: RecruitIdSchema });
-var invitationIdParam = import_zod20.z.object({ invitationId: InvitationIdSchema });
-var planIdParam = import_zod20.z.object({ planId: PlanIdSchema });
-var couponIdParam = import_zod20.z.object({ couponId: CouponIdSchema });
-var friendRequestIdParam = import_zod20.z.object({ requestId: FriendRequestIdSchema });
+var memberIdParam = import_zod19.z.object({ memberId: MemberIdSchema });
+var authorIdParam = 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 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에서만 작동하도록 백엔드에서 수정해야함 
   },
   members: {
     me: endpoint({ method: "GET", path: "/members/me", response: MemberResponseSchema }),
-    summary: endpoint({ method: "GET", path: "/members/me/summary", response: MemberSummaryResponseSchema }),
-    detail: endpoint({ method: "GET", path: "/members/:memberId", pathParams: memberIdParam, response: ProfileDetailResponseSchema }),
-    updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, response: ProfileDetailResponseSchema }),
-    onboarding: endpoint({ method: "POST", path: "/members/me/onboarding", body: OnboardingRequestSchema, response: PreferenceMetaResponseSchema }),
-    updateOnboardingPreferences: endpoint({ method: "PATCH", path: "/members/me/preferences", body: OnboardingPreferenceRequestSchema, response: PreferenceMetaResponseSchema })
+    myProfile: endpoint({ method: "GET", path: "/members/me/detail", 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 }),
+    createProfile: endpoint({ method: "POST", path: "/members/onboarding", body: CreateProfileRequestSchema, response: NoContentSchema }),
+    updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, response: NoContentSchema }),
+    updatePreferences: endpoint({ method: "PATCH", path: "/members/me/preferences", 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) })
   },
   articles: {
-    list: endpoint({ method: "GET", path: "/articles", response: PageArticleSummaryResponseSchema }),
+    list: endpoint({ method: "GET", path: "/articles/home", query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
+    byAuthor: endpoint({ method: "GET", path: "/articles/by-author/:authorId", pathParams: authorIdParam, response: PageArticleSummaryResponseSchema }),
+    my: endpoint({ method: "GET", path: "/articles/my", response: PageArticleSummaryResponseSchema }),
     detail: endpoint({ method: "GET", path: "/articles/:articleId", pathParams: articleIdParam, response: ArticleDetailResponseSchema }),
-    create: endpoint({ method: "POST", path: "/articles", body: ArticlePostRequestSchema, response: CreateArticleResponseSchema }),
+    create: endpoint({ method: "POST", path: "/articles", body: CreateArticleRequestSchema, response: NoContentSchema }),
+    createComment: endpoint({ method: "POST", path: "/articles/:articleId/comments", pathParams: articleIdParam, body: CreateCommentRequestSchema, response: NoContentSchema }),
+    presignArticleImage: endpoint({ method: "POST", path: "/uploads/presign-article", response: PresignArticleResponseSchema }),
     delete: endpoint({ method: "DELETE", path: "/articles/:articleId", pathParams: articleIdParam, response: NoContentSchema }),
-    createComment: endpoint({ method: "POST", path: "/articles/:articleId/comments", pathParams: articleIdParam, body: CommentPostRequestSchema, response: CreateCommentResponseSchema }),
-    deleteComment: endpoint({ method: "DELETE", path: "/articles/:articleId/comments/:commentId", pathParams: articleIdParam.merge(commentIdParam), response: NoContentSchema }),
-    presignArticleImage: endpoint({ method: "POST", path: "/uploads/articles/presign", response: PresignUploadResponseSchema }),
-    presignProfileImage: endpoint({ method: "POST", path: "/uploads/profiles/presign", response: PresignUploadResponseSchema })
+    deleteComment: endpoint({ method: "DELETE", path: "/articles/:articleId/comments/:commentId", pathParams: articleIdParam.merge(commentIdParam), response: NoContentSchema })
+    // TODO: 게시물 수정 기능
   },
   recruits: {
-    list: endpoint({ method: "GET", path: "/recruits", response: import_zod20.z.array(RecruitResponseSchema) }),
-    detail: endpoint({ method: "GET", path: "/recruits/:recruitId", pathParams: recruitIdParam, response: RecruitResponseSchema }),
-    create: endpoint({ method: "POST", path: "/recruits", body: RecruitRequestSchema, response: CreateRecruitResponseSchema }),
-    close: endpoint({ method: "PATCH", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema }),
-    join: endpoint({ method: "POST", path: "/recruits/:recruitId/join", pathParams: recruitIdParam, response: NoContentSchema })
+    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 })
   },
   invitations: {
-    list: endpoint({ method: "GET", path: "/invitations", response: import_zod20.z.array(InvitationListItemResponseSchema) }),
-    send: endpoint({ method: "POST", path: "/invitations", body: InvitationPostRequestSchema, response: SendInvitationResponseSchema }),
+    list: endpoint({ method: "GET", path: "/invitations", response: import_zod19.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 }),
     accept: endpoint({ method: "POST", path: "/invitations/:invitationId/accept", pathParams: invitationIdParam, response: AcceptInvitationResponseSchema }),
-    reject: endpoint({ method: "POST", path: "/invitations/:invitationId/reject", pathParams: invitationIdParam, response: RejectInvitationResponseSchema })
+    reject: endpoint({ method: "POST", path: "/invitations/:invitationId/reject", pathParams: invitationIdParam, response: NoContentSchema })
   },
   plans: {
-    list: endpoint({ method: "GET", path: "/plans", response: import_zod20.z.array(PlanResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/plans", query: PlanListQuerySchema, response: import_zod19.z.array(PlanResponseSchema) }),
     detail: endpoint({ method: "GET", path: "/plans/:planId", pathParams: planIdParam, response: PlanResponseSchema }),
-    create: endpoint({ method: "POST", path: "/plans", body: CreatePlanRequestSchema, response: PlanResponseSchema })
-  },
-  mealStatus: {
-    get: endpoint({ method: "GET", path: "/members/me/meal-status", response: MealStatusResponseSchema }),
-    update: endpoint({ method: "PATCH", path: "/members/me/meal-status", body: UpdateMealStatusRequestSchema, response: NoContentSchema })
+    cancel: endpoint({ method: "PATCH", path: "/plans/:planId/cancel", pathParams: planIdParam, response: NoContentSchema })
   },
   friends: {
-    list: endpoint({ method: "GET", path: "/friends", response: import_zod20.z.array(FriendListItemResponseSchema) }),
-    meals: endpoint({ method: "GET", path: "/friends/meals", query: import_zod20.z.object({ filter: FriendMealFilterSchema.optional() }), response: import_zod20.z.array(FriendMealItemResponseSchema) }),
-    blocks: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod20.z.array(FriendBlockItemResponseSchema) }),
-    request: endpoint({ method: "POST", path: "/friends/requests", body: FriendActionRequestSchema, response: FriendRequestItemResponseSchema }),
+    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/outgoint", response: import_zod19.z.array(FriendRequestItemResponseSchema) }),
+    sendRequest: endpoint({ method: "POST", path: "/friends/requests/:memberId", pathParams: friendRequestIdParam, response: NoContentSchema }),
     acceptRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/accept", pathParams: friendRequestIdParam, response: NoContentSchema }),
     rejectRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/reject", pathParams: friendRequestIdParam, response: NoContentSchema }),
-    block: endpoint({ method: "POST", path: "/friends/blocks", body: FriendActionRequestSchema, response: NoContentSchema }),
-    unblock: endpoint({ method: "DELETE", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema })
-  },
-  preferences: {
-    list: endpoint({ method: "GET", path: "/preferences", response: import_zod20.z.array(FoodPreferenceResponseSchema) })
+    block: endpoint({ method: "POST", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
+    cancelRequest: endpoint({ method: "DELETE", path: "/friends/requests/:requestId", pathParams: friendRequestIdParam, response: NoContentSchema }),
+    unblock: endpoint({ method: "DELETE", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
+    unfriend: endpoint({ method: "DELETE", path: "/friends/:memberId", pathParams: memberIdParam, response: NoContentSchema })
   },
   coupons: {
-    list: endpoint({ method: "GET", path: "/coupons", response: import_zod20.z.array(CouponResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/coupons", response: import_zod19.z.array(CouponResponseSchema) }),
     use: endpoint({ method: "PATCH", 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: ClaimChallengeRewardResponseSchema })
+    claimReward: endpoint({ method: "POST", path: "/challenges/rewards", body: ClaimChallengeRewardRequestSchema, response: NoContentSchema })
   },
   referrals: {
+    list: endpoint({ method: "GET", path: "/referrals", response: import_zod19.z.array(ReferralItemResponseSchema) }),
     create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
-    list: endpoint({ method: "GET", path: "/referrals", response: import_zod20.z.array(ReferralItemResponseSchema) }),
     redeem: endpoint({ method: "POST", path: "/referrals/redeem", body: RedeemReferralRequestSchema, response: NoContentSchema })
+  },
+  room: {
+    //TODO: 방 입장 기능
+  },
+  health: {
+    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod19.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;
@@ -723,6 +714,12 @@ var toRecruitId = (value) => RecruitIdSchema.parse(value);
 var toInvitationId = (value) => InvitationIdSchema.parse(value);
 var toRoomId = (value) => RoomIdSchema.parse(value);
 var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
+var toCommentId = (value) => CommentIdSchema.parse(value);
+var toPlanId = (value) => PlanIdSchema.parse(value);
+var toCouponId = (value) => CouponIdSchema.parse(value);
+var toSubscriptionId = (value) => SubscriptionIdSchema.parse(value);
+var toFriendRequestId = (value) => FriendRequestIdSchema.parse(value);
+var toReferralCode = (value) => ReferralCodeSchema.parse(value);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiFailureSchema,
@@ -732,7 +729,9 @@ var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
   CommentIdSchema,
   CouponIdSchema,
   CreatedEntityIdResponseSchema,
-  CreatedIdResponseSchema,
+  FoodCodeSchema,
+  FoodLabelSchema,
+  FoodSchema,
   FriendRequestIdSchema,
   ISODateStringSchema,
   ISODateTimeStringSchema,
@@ -743,16 +742,16 @@ var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
   NoParamsSchema,
   NoQuerySchema,
   NonEmptyStringIdSchema,
-  PageRequestSchema,
+  PageMetaSchema,
+  PageQuerySchema,
   PageResponseSchema,
-  PageableObjectSchema,
   PlanIdSchema,
   PositiveIntIdSchema,
   RecruitIdSchema,
   ReferralCodeSchema,
   RestaurantIdSchema,
   RoomIdSchema,
-  SortObjectSchema,
+  SortDirectionSchema,
   SubscriptionIdSchema,
   TimeHHmmStringSchema,
   UserIdSchema,
@@ -761,9 +760,15 @@ var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
   makeApiResponseSchema,
   makeApiSuccessSchema,
   toArticleId,
+  toCommentId,
+  toCouponId,
+  toFriendRequestId,
   toInvitationId,
   toMemberId,
+  toPlanId,
   toRecruitId,
+  toReferralCode,
   toRestaurantId,
-  toRoomId
+  toRoomId,
+  toSubscriptionId
 });