@kimdaegyu/babmukdang-shared 1.1.0 → 1.1.3

package/dist/{chunk-NW5O4R7M.js → chunk-GTVEQYJW.js}

@@ -1,8 +1,8 @@
 import {
   RestaurantIdSchema
-} from "./chunk-UFVPFUMI.js";
+} from "./chunk-H77ISYYC.js";
 
-// src/domain/restaurant/schema/restaurant.schema.ts
+// src/domain/restaurant/restaurant.schema.ts
 import { z } from "zod";
 var RestaurantSchema = z.object({
   restaurantId: RestaurantIdSchema,

package/dist/{chunk-UFVPFUMI.js → chunk-H77ISYYC.js}

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/domain/common/schema/id.schema.ts
 import { z } from "zod";
 var PositiveIntIdSchema = z.number().int().positive();
@@ -15,8 +21,15 @@ var CouponIdSchema = PositiveIntIdSchema.brand();
 var SubscriptionIdSchema = PositiveIntIdSchema.brand();
 var FriendRequestIdSchema = PositiveIntIdSchema.brand();
 var ReferralCodeSchema = z.string().min(4).max(64).brand();
+var FoodCodeSchema = NonEmptyStringIdSchema.brand();
+var FoodLabelSchema = NonEmptyStringIdSchema.brand();
+var FoodSchema = z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema
+});
 
 export {
+  __export,
   PositiveIntIdSchema,
   NonEmptyStringIdSchema,
   MemberIdSchema,
@@ -31,5 +44,8 @@ export {
   CouponIdSchema,
   SubscriptionIdSchema,
   FriendRequestIdSchema,
-  ReferralCodeSchema
+  ReferralCodeSchema,
+  FoodCodeSchema,
+  FoodLabelSchema,
+  FoodSchema
 };

package/dist/{chunk-FCE6KXNO.js → chunk-J76VB5SE.js}

@@ -1,8 +1,8 @@
 import {
-  MemberResponseSchema
-} from "./chunk-MP7TEKEI.js";
+  MemberCoreSchema
+} from "./chunk-KRVEQVRC.js";
 
-// src/domain/auth/schema/auth.schema.ts
+// src/domain/auth/auth.schema.ts
 import { z } from "zod";
 var TokenResponseSchema = z.object({
   accessToken: z.string().min(1),
@@ -19,7 +19,7 @@ var SignupRequestSchema = z.object({
   profileImageUrl: z.string().url().nullable().optional()
 });
 var SignupResponseSchema = z.object({
-  member: MemberResponseSchema
+  member: MemberCoreSchema
 });
 
 export {

package/dist/chunk-JEUH3JDZ.js

@@ -0,0 +1,299 @@
+import {
+  FriendMealItemResponseSchema,
+  FriendMealQuerySchema,
+  MealStatusResponseSchema,
+  UpdateMealStatusRequestSchema
+} from "./chunk-UJJMW7II.js";
+import {
+  PlanListQuerySchema,
+  PlanResponseSchema
+} from "./chunk-W3YQYI4R.js";
+import {
+  ChallengeStatusResponseSchema,
+  ClaimChallengeRewardRequestSchema,
+  CouponResponseSchema,
+  RedeemReferralRequestSchema,
+  ReferralCreateResponseSchema,
+  ReferralItemResponseSchema
+} from "./chunk-VAWYU5JG.js";
+import {
+  ArticleDetailResponseSchema,
+  ArticleListQuerySchema,
+  CreateArticleRequestSchema,
+  CreateCommentRequestSchema,
+  PageArticleSummaryResponseSchema,
+  PageQuerySchema,
+  PresignArticleResponseSchema,
+  SortDirectionSchema
+} from "./chunk-TY4WZEIZ.js";
+import {
+  LoginRequestSchema,
+  SignupRequestSchema,
+  SignupResponseSchema,
+  TokenResponseSchema
+} from "./chunk-J76VB5SE.js";
+import {
+  FriendBlockItemResponseSchema,
+  FriendListItemResponseSchema,
+  FriendRequestItemResponseSchema
+} from "./chunk-U6OQQOPN.js";
+import {
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+import {
+  AcceptInvitationResponseSchema,
+  CreateInvitationRequestSchema,
+  InvitationListItemResponseSchema,
+  SendInvitationResponseSchema
+} from "./chunk-YGFAVC5N.js";
+import {
+  CreateProfileRequestSchema,
+  MemberCoreSchema,
+  MemberResponseSchema,
+  MemberSearchQuerySchema,
+  MemberSerachResponseSchema,
+  PresignProfileResponseSchema,
+  ProfileDetailResponseSchema,
+  UpdatePreferenceRequestSchema,
+  UpdateProfileRequestSchema
+} from "./chunk-KRVEQVRC.js";
+import {
+  ArticleIdSchema,
+  CommentIdSchema,
+  CouponIdSchema,
+  FriendRequestIdSchema,
+  InvitationIdSchema,
+  MemberIdSchema,
+  PlanIdSchema,
+  RecruitIdSchema,
+  ReferralCodeSchema,
+  RestaurantIdSchema,
+  RoomIdSchema,
+  SubscriptionIdSchema
+} from "./chunk-H77ISYYC.js";
+
+// src/domain/recruit/recruit.schema.ts
+import { z as z4 } from "zod";
+
+// src/domain/common/contracts/api.ts
+import { z as z2 } from "zod";
+
+// src/domain/common/contracts/endpoint.ts
+import { z } from "zod";
+var NoBodySchema = z.undefined();
+var NoQuerySchema = z.undefined();
+var NoParamsSchema = 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 = z2.object({ memberId: MemberIdSchema });
+var authorIdParam = z2.object({ memberId: MemberIdSchema });
+var articleIdParam = z2.object({ articleId: ArticleIdSchema });
+var commentIdParam = z2.object({ commentId: CommentIdSchema });
+var recruitIdParam = z2.object({ recruitId: RecruitIdSchema });
+var invitationIdParam = z2.object({ invitationId: InvitationIdSchema });
+var planIdParam = z2.object({ planId: PlanIdSchema });
+var couponIdParam = z2.object({ couponId: CouponIdSchema });
+var friendRequestIdParam = z2.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: z2.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: z2.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: z2.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: z2.array(FriendListItemResponseSchema) }),
+    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: z2.array(FriendBlockItemResponseSchema) }),
+    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: z2.array(FriendRequestItemResponseSchema) }),
+    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoint", response: z2.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: z2.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: z2.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: z2.string() })
+  }
+};
+
+// src/domain/common/schema/envelope.schema.ts
+import { z as z3 } from "zod";
+var NoContentSchema = z3.null();
+var ApiSuccessSchema = (data) => z3.object({
+  success: z3.literal(true),
+  code: z3.number().int(),
+  message: z3.string(),
+  data
+});
+var ApiFailureSchema = z3.object({
+  success: z3.literal(false),
+  status: z3.number().int(),
+  code: z3.string(),
+  message: z3.string()
+});
+var ApiResponseSchema = (data) => z3.union([ApiSuccessSchema(data), ApiFailureSchema]);
+var CreatedEntityIdResponseSchema = z3.discriminatedUnion("entity", [
+  z3.object({ entity: z3.literal("article"), id: ArticleIdSchema }),
+  z3.object({ entity: z3.literal("comment"), id: CommentIdSchema }),
+  z3.object({ entity: z3.literal("recruit"), id: RecruitIdSchema }),
+  z3.object({ entity: z3.literal("invitation"), id: InvitationIdSchema }),
+  z3.object({ entity: z3.literal("subscription"), id: SubscriptionIdSchema }),
+  z3.object({ entity: z3.literal("coupon"), id: CouponIdSchema }),
+  z3.object({ entity: z3.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);
+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);
+
+// src/domain/recruit/recruit.schema.ts
+var RecruitStatusSchema = z4.enum(["OPEN", "CLOSED", "EXPIRED"]);
+var RecruitParticipantSchema = MemberCoreSchema.extend({});
+var RecruitSortBySchema = z4.enum(["createdAt", "deadline", "participantCount"]);
+var RecruitListQuerySchema = PageQuerySchema.extend({
+  sortBy: RecruitSortBySchema.default("createdAt"),
+  direction: SortDirectionSchema.default("desc")
+});
+var RecruitResponseSchema = z4.object({
+  targetCount: z4.number().int().min(2),
+  meetingAt: ISODateTimeStringSchema,
+  location: z4.string().min(1),
+  message: z4.string().max(500),
+  recruitId: RecruitIdSchema,
+  status: RecruitStatusSchema,
+  createdAt: ISODateTimeStringSchema,
+  expiredAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema,
+  author: MemberCoreSchema,
+  participants: z4.array(RecruitParticipantSchema)
+});
+var RecruitListResponseSchema = z4.array(RecruitResponseSchema);
+var CreateRecruitRequestSchema = z4.object({
+  targetCount: z4.number().int().min(2),
+  meetingAt: ISODateTimeStringSchema,
+  location: z4.string().min(1),
+  message: z4.string().max(500)
+});
+var CreateRecruitResponseSchema = z4.object({
+  recruitId: RecruitIdSchema
+});
+
+export {
+  RecruitStatusSchema,
+  RecruitSortBySchema,
+  RecruitListQuerySchema,
+  RecruitListResponseSchema,
+  CreateRecruitRequestSchema,
+  CreateRecruitResponseSchema,
+  NoBodySchema,
+  NoQuerySchema,
+  NoParamsSchema,
+  endpoint,
+  apiContract,
+  NoContentSchema,
+  ApiSuccessSchema,
+  ApiFailureSchema,
+  ApiResponseSchema,
+  CreatedEntityIdResponseSchema,
+  makeApiResponseSchema,
+  makeApiSuccessSchema,
+  toMemberId,
+  toArticleId,
+  toRecruitId,
+  toInvitationId,
+  toRoomId,
+  toRestaurantId,
+  toCommentId,
+  toPlanId,
+  toCouponId,
+  toSubscriptionId,
+  toFriendRequestId,
+  toReferralCode
+};

package/dist/chunk-KRVEQVRC.js

@@ -0,0 +1,72 @@
+import {
+  FoodSchema,
+  MemberIdSchema
+} from "./chunk-H77ISYYC.js";
+
+// src/domain/member/member.schema.ts
+import { z as z2 } from "zod";
+
+// src/domain/common/contracts/upload.ts
+import z from "zod";
+var PresignUploadResponseSchema = z.object({
+  key: z.string(),
+  putUrl: z.string().url(),
+  cdnUrl: z.string().url()
+});
+
+// src/domain/member/member.schema.ts
+var MemberRoleSchema = z2.enum(["USER", "ADMIN"]);
+var MemberCoreSchema = z2.object({
+  memberId: MemberIdSchema,
+  username: z2.string().min(1).max(50),
+  profileImageUrl: z2.string().url().nullable().optional()
+});
+var PresignProfileResponseSchema = PresignUploadResponseSchema.extend({});
+var MemberResponseSchema = MemberCoreSchema.pick({
+  memberId: true,
+  username: true,
+  profileImageUrl: true
+});
+var MemberSearchQuerySchema = z2.object({
+  email: z2.string().email().optional(),
+  username: z2.string().optional()
+});
+var MemberSerachResponseSchema = z2.array(MemberCoreSchema);
+var MemberDetailSchema = MemberCoreSchema.extend({
+  bio: z2.string().nullable(),
+  friendConunt: z2.number().int().min(0).default(0),
+  completedPlans: z2.number().int().min(0).default(0),
+  uncompletedPlans: z2.number().int().min(0).default(0)
+});
+var FoodPreferenceItemSchema = FoodSchema.extend({});
+var MemberFoodPreferenceSchema = z2.object({
+  liked: z2.array(FoodPreferenceItemSchema).optional(),
+  disliked: z2.array(FoodPreferenceItemSchema).optional(),
+  allergy: z2.array(FoodPreferenceItemSchema).optional()
+});
+var ProfileDetailResponseSchema = MemberDetailSchema;
+var UpdateProfileRequestSchema = z2.object({
+  username: z2.string().min(1).max(50),
+  profileImageUrl: z2.string().url().nullable(),
+  bio: z2.string().max(500).nullable()
+});
+var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
+var CreateProfileRequestSchema = UpdateProfileRequestSchema.merge(
+  UpdatePreferenceRequestSchema
+);
+
+export {
+  PresignUploadResponseSchema,
+  MemberRoleSchema,
+  MemberCoreSchema,
+  PresignProfileResponseSchema,
+  MemberResponseSchema,
+  MemberSearchQuerySchema,
+  MemberSerachResponseSchema,
+  MemberDetailSchema,
+  MemberFoodPreferenceSchema,
+  ProfileDetailResponseSchema,
+  UpdateProfileRequestSchema,
+  UpdatePreferenceRequestSchema,
+  CreateProfileRequestSchema
+};

package/dist/{chunk-EJKRR2MZ.js → chunk-M5OSCHMV.js}

@@ -1,27 +1,26 @@
 import {
   RestaurantSchema
-} from "./chunk-NW5O4R7M.js";
+} from "./chunk-GTVEQYJW.js";
 import {
-  MemberResponseSchema
-} from "./chunk-MP7TEKEI.js";
+  ISODateStringSchema,
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
 import {
+  MemberCoreSchema
+} from "./chunk-KRVEQVRC.js";
+import {
+  FoodCodeSchema,
+  FoodSchema,
   MemberIdSchema,
   RestaurantIdSchema,
   RoomIdSchema
-} from "./chunk-UFVPFUMI.js";
-import {
-  ISODateStringSchema,
-  ISODateTimeStringSchema
-} from "./chunk-HRM3FQPL.js";
+} from "./chunk-H77ISYYC.js";
 
 // src/domain/room/schema/room.schema.ts
 import { z } from "zod";
-var MenuCodeSchema = z.string().min(1).brand();
+var MenuCodeSchema = FoodCodeSchema;
 var LocationIdSchema = z.string().min(1).brand();
-var MenuSchema = z.object({
-  code: MenuCodeSchema,
-  label: z.string()
-});
+var MenuSchema = FoodSchema.extend({});
 var LocationCandidateSchema = z.object({
   locationId: LocationIdSchema,
   placeName: z.string(),
@@ -29,7 +28,7 @@ var LocationCandidateSchema = z.object({
   lng: z.number(),
   address: z.string()
 });
-var ParticipantSchema = MemberResponseSchema.extend({
+var ParticipantSchema = MemberCoreSchema.extend({
   ready: z.boolean()
 });
 var RecruitRoomStageSchema = z.enum([
@@ -74,7 +73,7 @@ var RoomSocketErrorSchema = z.object({
 });
 var ChatMessageResponseSchema = z.object({
   messageId: z.string(),
-  user: MemberResponseSchema,
+  user: MemberCoreSchema,
   message: z.string(),
   createdAt: ISODateTimeStringSchema
 });

package/dist/chunk-TY4WZEIZ.js

@@ -0,0 +1,109 @@
+import {
+  RestaurantSchema
+} from "./chunk-GTVEQYJW.js";
+import {
+  ISODateStringSchema,
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+import {
+  MemberCoreSchema,
+  PresignUploadResponseSchema
+} from "./chunk-KRVEQVRC.js";
+import {
+  ArticleIdSchema,
+  CommentIdSchema,
+  FoodSchema,
+  MemberIdSchema
+} from "./chunk-H77ISYYC.js";
+
+// src/domain/article/article.schema.ts
+import { z as z2 } from "zod";
+
+// src/domain/common/schema/pagination.schema.ts
+import { z } from "zod";
+var PageQuerySchema = z.object({
+  page: z.number().int().min(0).optional().default(0),
+  size: z.number().int().min(1).max(100).optional().default(20)
+});
+var PageMetaSchema = z.object({
+  page: z.number().int().min(0),
+  size: z.number().int().min(1),
+  totalItems: z.number().int().min(0),
+  totalPages: z.number().int().min(0),
+  hasNext: z.boolean(),
+  hasPrevious: z.boolean()
+});
+var PageResponseSchema = (item) => z.object({
+  items: z.array(item),
+  meta: PageMetaSchema
+});
+var SortDirectionSchema = z.enum(["asc", "desc"]);
+
+// src/domain/article/article.schema.ts
+var ArticleSortBySchema = z2.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: z2.number().min(0).max(1),
+  tsUtc: ISODateTimeStringSchema.optional()
+});
+var CreateArticleRequestSchema = z2.object({
+  imageUrl: z2.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  taggedMemberIds: z2.array(MemberIdSchema).default([]),
+  foodAnalysis: FoodAnalysisResultSchema.optional()
+});
+var CreateCommentRequestSchema = z2.object({
+  content: z2.string().min(1).max(500),
+  parentCommentId: CommentIdSchema.nullish()
+});
+var ArticleCommentSchema = z2.object({
+  commentId: CommentIdSchema,
+  author: MemberCoreSchema,
+  parentCommentId: CommentIdSchema.nullable(),
+  content: z2.string(),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var ArticleCoreSchema = z2.object({
+  articleId: ArticleIdSchema,
+  author: MemberCoreSchema,
+  imageUrl: z2.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema,
+  taggedMembers: z2.array(MemberCoreSchema)
+});
+var ArticleSummaryResponseSchema = ArticleCoreSchema.extend({
+  likeCount: z2.number().int().min(0),
+  commentCount: z2.number().int().min(0),
+  likedByMe: z2.boolean()
+});
+var ArticleDetailResponseSchema = ArticleSummaryResponseSchema.extend({
+  comments: z2.array(ArticleCommentSchema).optional()
+});
+var PageArticleSummaryResponseSchema = PageResponseSchema(ArticleSummaryResponseSchema);
+
+export {
+  PageQuerySchema,
+  PageMetaSchema,
+  PageResponseSchema,
+  SortDirectionSchema,
+  ArticleSortBySchema,
+  ArticleListQuerySchema,
+  PresignArticleResponseSchema,
+  FoodAnalysisResultSchema,
+  CreateArticleRequestSchema,
+  CreateCommentRequestSchema,
+  ArticleCommentSchema,
+  ArticleCoreSchema,
+  ArticleSummaryResponseSchema,
+  ArticleDetailResponseSchema,
+  PageArticleSummaryResponseSchema
+};

package/dist/chunk-U6OQQOPN.js

@@ -0,0 +1,35 @@
+import {
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+import {
+  MemberCoreSchema
+} from "./chunk-KRVEQVRC.js";
+import {
+  FriendRequestIdSchema
+} from "./chunk-H77ISYYC.js";
+
+// src/domain/friend/friend.schema.ts
+import { z } from "zod";
+var FriendRequestStatusSchema = z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
+var FriendListItemResponseSchema = MemberCoreSchema.extend({
+  friendSince: ISODateTimeStringSchema
+});
+var FriendBlockItemResponseSchema = MemberCoreSchema.extend({
+  blockedAt: ISODateTimeStringSchema
+});
+var FriendRequestMemberSchema = MemberCoreSchema;
+var FriendRequestItemResponseSchema = z.object({
+  requestId: FriendRequestIdSchema,
+  requester: FriendRequestMemberSchema,
+  recipient: FriendRequestMemberSchema,
+  status: FriendRequestStatusSchema,
+  requestedAt: ISODateTimeStringSchema
+});
+
+export {
+  FriendRequestStatusSchema,
+  FriendListItemResponseSchema,
+  FriendBlockItemResponseSchema,
+  FriendRequestMemberSchema,
+  FriendRequestItemResponseSchema
+};

package/dist/chunk-UJJMW7II.js

@@ -0,0 +1,37 @@
+import {
+  ISODateStringSchema
+} from "./chunk-HRM3FQPL.js";
+import {
+  MemberCoreSchema
+} from "./chunk-KRVEQVRC.js";
+
+// src/domain/meal/meal.schema.ts
+import { z } from "zod";
+var MealStatusResponseSchema = z.object({
+  hungry: z.boolean(),
+  label: z.string(),
+  updatedAt: ISODateStringSchema,
+  secondsToAutoOff: z.number().int().min(0)
+});
+var MealStatusActionSchema = z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
+var UpdateMealStatusRequestSchema = z.object({
+  action: MealStatusActionSchema.optional().default("SET_MANNUALY")
+});
+var MealStatusSchema = z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
+var FriendMealQuerySchema = z.object({
+  status: MealStatusSchema.optional().default("ALL")
+});
+var FriendMealItemResponseSchema = MemberCoreSchema.extend({
+  hungry: z.boolean(),
+  label: z.string(),
+  updatedAt: ISODateStringSchema
+});
+
+export {
+  MealStatusResponseSchema,
+  MealStatusActionSchema,
+  UpdateMealStatusRequestSchema,
+  MealStatusSchema,
+  FriendMealQuerySchema,
+  FriendMealItemResponseSchema
+};