@kimdaegyu/babmukdang-shared 1.0.7 → 1.1.1

package/dist/domain/common/index.cjs

@@ -0,0 +1,756 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/domain/common/index.ts
+var common_exports = {};
+__export(common_exports, {
+  ApiFailureSchema: () => ApiFailureSchema,
+  ApiResponseSchema: () => ApiResponseSchema,
+  ApiSuccessSchema: () => ApiSuccessSchema,
+  ArticleIdSchema: () => ArticleIdSchema,
+  CommentIdSchema: () => CommentIdSchema,
+  CouponIdSchema: () => CouponIdSchema,
+  CreatedEntityIdResponseSchema: () => CreatedEntityIdResponseSchema,
+  FoodCodeSchema: () => FoodCodeSchema,
+  FoodLabelSchema: () => FoodLabelSchema,
+  FoodSchema: () => FoodSchema,
+  FriendRequestIdSchema: () => FriendRequestIdSchema,
+  ISODateStringSchema: () => ISODateStringSchema,
+  ISODateTimeStringSchema: () => ISODateTimeStringSchema,
+  InvitationIdSchema: () => InvitationIdSchema,
+  MemberIdSchema: () => MemberIdSchema,
+  NoBodySchema: () => NoBodySchema,
+  NoContentSchema: () => NoContentSchema,
+  NoParamsSchema: () => NoParamsSchema,
+  NoQuerySchema: () => NoQuerySchema,
+  NonEmptyStringIdSchema: () => NonEmptyStringIdSchema,
+  PageMetaSchema: () => PageMetaSchema,
+  PageQuerySchema: () => PageQuerySchema,
+  PageResponseSchema: () => PageResponseSchema,
+  PlanIdSchema: () => PlanIdSchema,
+  PositiveIntIdSchema: () => PositiveIntIdSchema,
+  RecruitIdSchema: () => RecruitIdSchema,
+  ReferralCodeSchema: () => ReferralCodeSchema,
+  RestaurantIdSchema: () => RestaurantIdSchema,
+  RoomIdSchema: () => RoomIdSchema,
+  SortDirectionSchema: () => SortDirectionSchema,
+  SubscriptionIdSchema: () => SubscriptionIdSchema,
+  TimeHHmmStringSchema: () => TimeHHmmStringSchema,
+  UserIdSchema: () => UserIdSchema,
+  apiContract: () => apiContract,
+  endpoint: () => endpoint,
+  makeApiResponseSchema: () => makeApiResponseSchema,
+  makeApiSuccessSchema: () => makeApiSuccessSchema,
+  toArticleId: () => toArticleId,
+  toInvitationId: () => toInvitationId,
+  toMemberId: () => toMemberId,
+  toRecruitId: () => toRecruitId,
+  toRestaurantId: () => toRestaurantId,
+  toRoomId: () => toRoomId
+});
+module.exports = __toCommonJS(common_exports);
+
+// src/domain/common/contracts/api.ts
+var import_zod19 = 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");
+var isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
+var ISODateStringSchema = import_zod.z.string().regex(isoDateRegex, "Expected ISO date string in YYYY-MM-DD format");
+var ISODateTimeStringSchema = import_zod.z.string().datetime({ offset: true, message: "Expected ISO datetime string" });
+var TimeHHmmStringSchema = import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Expected time string in HH:mm format");
+
+// src/domain/common/schema/id.schema.ts
+var import_zod2 = require("zod");
+var PositiveIntIdSchema = import_zod2.z.number().int().positive();
+var NonEmptyStringIdSchema = import_zod2.z.string().min(1);
+var MemberIdSchema = PositiveIntIdSchema.brand();
+var UserIdSchema = MemberIdSchema;
+var ArticleIdSchema = PositiveIntIdSchema.brand();
+var CommentIdSchema = PositiveIntIdSchema.brand();
+var RecruitIdSchema = PositiveIntIdSchema.brand();
+var PlanIdSchema = PositiveIntIdSchema.brand();
+var InvitationIdSchema = PositiveIntIdSchema.brand();
+var RoomIdSchema = NonEmptyStringIdSchema.brand();
+var RestaurantIdSchema = NonEmptyStringIdSchema.brand();
+var CouponIdSchema = PositiveIntIdSchema.brand();
+var SubscriptionIdSchema = PositiveIntIdSchema.brand();
+var FriendRequestIdSchema = PositiveIntIdSchema.brand();
+var ReferralCodeSchema = import_zod2.z.string().min(4).max(64).brand();
+var FoodCodeSchema = NonEmptyStringIdSchema.brand();
+var FoodLabelSchema = NonEmptyStringIdSchema.brand();
+var FoodSchema = import_zod2.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema
+});
+
+// src/domain/common/schema/pagination.schema.ts
+var import_zod3 = require("zod");
+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({
+  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/member.schema.ts
+var MemberRoleSchema = import_zod5.z.enum(["USER", "ADMIN"]);
+var MemberCoreSchema = import_zod5.z.object({
+  memberId: MemberIdSchema,
+  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 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
+);
+
+// src/domain/restaurant/restaurant.schema.ts
+var import_zod6 = require("zod");
+var RestaurantSchema = import_zod6.z.object({
+  restaurantId: RestaurantIdSchema,
+  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_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/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 CreateArticleRequestSchema = import_zod7.z.object({
+  imageUrl: import_zod7.z.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  taggedMemberIds: import_zod7.z.array(MemberIdSchema).default([]),
+  foodAnalysis: FoodAnalysisResultSchema.optional()
+});
+var CreateCommentRequestSchema = import_zod7.z.object({
+  content: import_zod7.z.string().min(1).max(500),
+  parentCommentId: CommentIdSchema.nullish()
+});
+var ArticleCommentSchema = import_zod7.z.object({
+  commentId: CommentIdSchema,
+  author: MemberCoreSchema,
+  parentCommentId: CommentIdSchema.nullable(),
+  content: import_zod7.z.string(),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var ArticleCoreSchema = import_zod7.z.object({
+  articleId: ArticleIdSchema,
+  author: MemberCoreSchema,
+  imageUrl: import_zod7.z.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema,
+  taggedMembers: import_zod7.z.array(MemberCoreSchema)
+});
+var ArticleSummaryResponseSchema = ArticleCoreSchema.extend({
+  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_zod7.z.array(ArticleCommentSchema).optional()
+});
+var PageArticleSummaryResponseSchema = PageResponseSchema(ArticleSummaryResponseSchema);
+
+// 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_zod8.z.object({
+  email: import_zod8.z.string().email(),
+  password: import_zod8.z.string().min(1)
+});
+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_zod8.z.object({
+  member: MemberCoreSchema
+});
+
+// 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 MonthProgressSchema = import_zod9.z.object({
+  count: import_zod9.z.number().int().min(0),
+  goal: import_zod9.z.number().int().positive()
+});
+var ChallengeStatusResponseSchema = import_zod9.z.object({
+  count: import_zod9.z.number().int().min(0)
+});
+var ClaimChallengeRewardRequestSchema = import_zod9.z.object({
+  type: RewardTypeSchema
+});
+var ClaimChallengeRewardResponseSchema = import_zod9.z.object({
+  rewardType: RewardTypeSchema,
+  claimed: import_zod9.z.boolean()
+});
+
+// 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 = MemberCoreSchema.extend({
+  blockedAt: ISODateTimeStringSchema
+});
+var FriendRequestMemberSchema = MemberCoreSchema;
+var FriendRequestItemResponseSchema = import_zod10.z.object({
+  requestId: FriendRequestIdSchema,
+  requester: FriendRequestMemberSchema,
+  recipient: FriendRequestMemberSchema,
+  status: FriendRequestStatusSchema,
+  requestedAt: ISODateTimeStringSchema
+});
+
+// src/domain/invitation/invitation.schema.ts
+var import_zod11 = require("zod");
+var CreateInvitationRequestSchema = import_zod11.z.object({
+  inviteeId: MemberIdSchema,
+  message: import_zod11.z.string().min(1).max(500)
+});
+var InvitationListItemResponseSchema = import_zod11.z.object({
+  invitationId: InvitationIdSchema,
+  inviterName: import_zod11.z.string(),
+  inviterProfileImageUrl: import_zod11.z.string().url().nullable().optional()
+});
+var SendInvitationResponseSchema = import_zod11.z.object({
+  invitationId: InvitationIdSchema
+});
+var AcceptInvitationResponseSchema = import_zod11.z.object({
+  invitationId: InvitationIdSchema,
+  room: import_zod11.z.object({
+    type: import_zod11.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(),
+  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/plan.schema.ts
+var import_zod14 = require("zod");
+
+// src/domain/room/schema/room.schema.ts
+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_zod13.z.string(),
+  lat: import_zod13.z.number(),
+  lng: import_zod13.z.number(),
+  address: import_zod13.z.string()
+});
+var ParticipantSchema = MemberCoreSchema.extend({
+  ready: import_zod13.z.boolean()
+});
+var RecruitRoomStageSchema = import_zod13.z.enum([
+  "waiting",
+  "location",
+  "location-vote",
+  "exclude-menu",
+  "menu",
+  "restaurant",
+  "finish"
+]);
+var InvitationRoomStageSchema = import_zod13.z.enum([
+  "waiting",
+  "date",
+  "time",
+  "location",
+  "location-vote",
+  "exclude-menu",
+  "menu",
+  "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({
+  roomId: RoomIdSchema
+});
+var RoomSocketErrorSchema = import_zod13.z.object({
+  code: import_zod13.z.string(),
+  message: import_zod13.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_zod13.z.object({
+  readyCount: import_zod13.z.number().int().min(0),
+  participantCount: import_zod13.z.number().int().min(0)
+});
+var FinalStateSchema = import_zod13.z.object({
+  location: LocationCandidateSchema.optional(),
+  excludeMenu: import_zod13.z.array(MenuSchema).optional(),
+  menu: MenuSchema.optional(),
+  restaurant: RestaurantSchema.optional(),
+  time: import_zod13.z.string().optional(),
+  date: ISODateStringSchema.optional()
+});
+var RoomInitialStateSchema = import_zod13.z.object({
+  participants: import_zod13.z.array(ParticipantSchema),
+  chat: import_zod13.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 DatePicksUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ memberId: MemberIdSchema, dates: import_zod13.z.array(ISODateStringSchema) })
+);
+var LocationCandidateAddUpdateResponseSchema = import_zod13.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 ExcludeMenuUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ memberId: MemberIdSchema, exclusions: import_zod13.z.array(MenuSchema) })
+);
+var MenuPickUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod13.z.array(MemberIdSchema) })
+);
+var RestaurantPickUpdateResponseSchema = import_zod13.z.array(
+  import_zod13.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod13.z.array(MemberIdSchema) })
+);
+
+// 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: MemberCoreSchema,
+  participants: import_zod14.z.array(MemberCoreSchema),
+  status: PlanStatusSchema,
+  type: PlanTypeSchema,
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var PlanListQuerySchema = import_zod14.z.object({});
+
+// 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_zod15.z.string().min(1),
+  message: import_zod15.z.string().max(500),
+  recruitId: RecruitIdSchema,
+  status: RecruitStatusSchema,
+  createdAt: ISODateTimeStringSchema,
+  expiredAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema,
+  author: MemberCoreSchema,
+  participants: import_zod15.z.array(RecruitParticipantSchema)
+});
+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/promotion/referral.schema.ts
+var import_zod16 = require("zod");
+var ReferralCreateResponseSchema = import_zod16.z.object({
+  code: ReferralCodeSchema,
+  link: import_zod16.z.string().url(),
+  expiresAt: ISODateTimeStringSchema
+});
+var ReferralItemResponseSchema = import_zod16.z.object({
+  code: ReferralCodeSchema,
+  createdAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema,
+  used: import_zod16.z.boolean(),
+  usedByMemberId: MemberIdSchema.nullable(),
+  usedByUsername: import_zod16.z.string().nullable()
+});
+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_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,
+  pathParams: contract.pathParams ?? NoParamsSchema,
+  query: contract.query ?? NoQuerySchema,
+  body: contract.body ?? NoBodySchema,
+  response: contract.response
+});
+
+// src/domain/common/contracts/api.ts
+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 }),
+    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/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: 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 }),
+    deleteComment: endpoint({ method: "DELETE", path: "/articles/:articleId/comments/:commentId", pathParams: articleIdParam.merge(commentIdParam), response: NoContentSchema })
+    // TODO: 게시물 수정 기능
+  },
+  recruits: {
+    list: endpoint({ method: "GET", path: "/recruits", query: RecruitListQuerySchema, response: RecruitListResponseSchema }),
+    create: endpoint({ method: "POST", path: "/recruits", body: CreateRecruitRequestSchema, response: CreateRecruitResponseSchema }),
+    join: endpoint({ method: "POST", path: "/recruits/:recruitId/join", pathParams: recruitIdParam, response: NoContentSchema }),
+    close: endpoint({ method: "PATCH", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema })
+  },
+  invitations: {
+    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: NoContentSchema })
+  },
+  plans: {
+    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 }),
+    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/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/: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_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: NoContentSchema })
+  },
+  referrals: {
+    list: endpoint({ method: "GET", path: "/referrals", response: import_zod19.z.array(ReferralItemResponseSchema) }),
+    create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
+    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;
+
+// src/domain/common/contracts/id.ts
+var toMemberId = (value) => MemberIdSchema.parse(value);
+var toArticleId = (value) => ArticleIdSchema.parse(value);
+var toRecruitId = (value) => RecruitIdSchema.parse(value);
+var toInvitationId = (value) => InvitationIdSchema.parse(value);
+var toRoomId = (value) => RoomIdSchema.parse(value);
+var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiFailureSchema,
+  ApiResponseSchema,
+  ApiSuccessSchema,
+  ArticleIdSchema,
+  CommentIdSchema,
+  CouponIdSchema,
+  CreatedEntityIdResponseSchema,
+  FoodCodeSchema,
+  FoodLabelSchema,
+  FoodSchema,
+  FriendRequestIdSchema,
+  ISODateStringSchema,
+  ISODateTimeStringSchema,
+  InvitationIdSchema,
+  MemberIdSchema,
+  NoBodySchema,
+  NoContentSchema,
+  NoParamsSchema,
+  NoQuerySchema,
+  NonEmptyStringIdSchema,
+  PageMetaSchema,
+  PageQuerySchema,
+  PageResponseSchema,
+  PlanIdSchema,
+  PositiveIntIdSchema,
+  RecruitIdSchema,
+  ReferralCodeSchema,
+  RestaurantIdSchema,
+  RoomIdSchema,
+  SortDirectionSchema,
+  SubscriptionIdSchema,
+  TimeHHmmStringSchema,
+  UserIdSchema,
+  apiContract,
+  endpoint,
+  makeApiResponseSchema,
+  makeApiSuccessSchema,
+  toArticleId,
+  toInvitationId,
+  toMemberId,
+  toRecruitId,
+  toRestaurantId,
+  toRoomId
+});