@kimdaegyu/babmukdang-shared 1.0.7 → 1.1.0

package/dist/chunk-F24BT6H4.js

@@ -0,0 +1,23 @@
+import {
+  MemberIdSchema
+} from "./chunk-UFVPFUMI.js";
+import {
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+
+// src/domain/preference/schema/preference.schema.ts
+import { z } from "zod";
+var FoodPreferenceTypeSchema = z.enum(["LIKE", "DISLIKE", "ALLERGY"]);
+var FoodPreferenceResponseSchema = z.object({
+  id: z.number().int().positive(),
+  memberId: MemberIdSchema,
+  foodCode: z.string(),
+  type: FoodPreferenceTypeSchema,
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+
+export {
+  FoodPreferenceTypeSchema,
+  FoodPreferenceResponseSchema
+};

package/dist/chunk-FCE6KXNO.js

@@ -0,0 +1,30 @@
+import {
+  MemberResponseSchema
+} from "./chunk-MP7TEKEI.js";
+
+// src/domain/auth/schema/auth.schema.ts
+import { z } from "zod";
+var TokenResponseSchema = z.object({
+  accessToken: z.string().min(1),
+  accessTokenMaxAge: z.number().int().positive()
+});
+var LoginRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1)
+});
+var SignupRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(8),
+  username: z.string().min(1).max(50),
+  profileImageUrl: z.string().url().nullable().optional()
+});
+var SignupResponseSchema = z.object({
+  member: MemberResponseSchema
+});
+
+export {
+  TokenResponseSchema,
+  LoginRequestSchema,
+  SignupRequestSchema,
+  SignupResponseSchema
+};

package/dist/chunk-HRM3FQPL.js

@@ -0,0 +1,12 @@
+// src/domain/common/schema/date.schema.ts
+import { z } from "zod";
+var isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
+var ISODateStringSchema = z.string().regex(isoDateRegex, "Expected ISO date string in YYYY-MM-DD format");
+var ISODateTimeStringSchema = z.string().datetime({ offset: true, message: "Expected ISO datetime string" });
+var TimeHHmmStringSchema = z.string().regex(/^\d{2}:\d{2}$/, "Expected time string in HH:mm format");
+
+export {
+  ISODateStringSchema,
+  ISODateTimeStringSchema,
+  TimeHHmmStringSchema
+};

package/dist/chunk-IJMADVK5.js

@@ -0,0 +1,27 @@
+import {
+  CouponIdSchema
+} from "./chunk-UFVPFUMI.js";
+import {
+  ISODateStringSchema
+} from "./chunk-HRM3FQPL.js";
+
+// src/domain/coupon/schema/coupon.schema.ts
+import { z } from "zod";
+var CouponTypeSchema = z.enum(["DISCOUNT", "SERVICE"]);
+var CouponStatusSchema = z.enum(["UNUSED", "USED"]);
+var CouponResponseSchema = z.object({
+  couponId: CouponIdSchema,
+  title: z.string(),
+  shopName: z.string(),
+  type: CouponTypeSchema,
+  condition: z.string(),
+  expiresAt: ISODateStringSchema,
+  used: z.boolean(),
+  thumbnailUrl: z.string().url()
+});
+
+export {
+  CouponTypeSchema,
+  CouponStatusSchema,
+  CouponResponseSchema
+};

package/dist/chunk-JCN37ARR.js

@@ -0,0 +1,52 @@
+import {
+  MemberResponseSchema
+} from "./chunk-MP7TEKEI.js";
+import {
+  FriendRequestIdSchema,
+  MemberIdSchema
+} from "./chunk-UFVPFUMI.js";
+import {
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+
+// src/domain/friend/schema/friend.schema.ts
+import { z } from "zod";
+var FriendMealFilterSchema = z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
+var FriendRequestStatusSchema = z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELED"
+]);
+var FriendMealItemResponseSchema = MemberResponseSchema.extend({
+  hungry: z.boolean(),
+  label: z.string()
+});
+var FriendListItemResponseSchema = MemberResponseSchema.extend({
+  friendSince: ISODateTimeStringSchema
+});
+var FriendBlockItemResponseSchema = MemberResponseSchema.extend({
+  blockedAt: ISODateTimeStringSchema
+});
+var FriendRequestMemberSchema = MemberResponseSchema;
+var FriendRequestItemResponseSchema = z.object({
+  requestId: FriendRequestIdSchema,
+  requester: FriendRequestMemberSchema,
+  recipient: FriendRequestMemberSchema,
+  status: FriendRequestStatusSchema,
+  requestedAt: ISODateTimeStringSchema
+});
+var FriendActionRequestSchema = z.object({
+  memberId: MemberIdSchema
+});
+
+export {
+  FriendMealFilterSchema,
+  FriendRequestStatusSchema,
+  FriendMealItemResponseSchema,
+  FriendListItemResponseSchema,
+  FriendBlockItemResponseSchema,
+  FriendRequestMemberSchema,
+  FriendRequestItemResponseSchema,
+  FriendActionRequestSchema
+};

package/dist/chunk-MP7TEKEI.js

@@ -0,0 +1,72 @@
+import {
+  MemberIdSchema
+} from "./chunk-UFVPFUMI.js";
+import {
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+
+// src/domain/member/schema/member.schema.ts
+import { z } from "zod";
+var MemberRoleSchema = z.enum(["USER", "ADMIN"]);
+var MemberCoreSchema = z.object({
+  memberId: MemberIdSchema,
+  username: z.string().min(1).max(50),
+  profileImageUrl: z.string().url().nullable()
+});
+var MemberResponseSchema = MemberCoreSchema.pick({
+  memberId: true,
+  username: true,
+  profileImageUrl: true
+});
+var MemberSummaryResponseSchema = MemberCoreSchema.extend({
+  friends: z.number().int().min(0).default(0),
+  completedPlans: z.number().int().min(0).default(0),
+  uncompletedPlans: z.number().int().min(0).default(0)
+});
+var AuthPrincipalSchema = z.object({
+  memberId: MemberIdSchema,
+  role: MemberRoleSchema
+});
+var ProfilePreferenceItemSchema = z.object({
+  code: z.string(),
+  label: z.string()
+});
+var ProfileDetailResponseSchema = MemberCoreSchema.extend({
+  bio: z.string().nullable(),
+  planCount: z.number().int().min(0),
+  likes: z.array(ProfilePreferenceItemSchema),
+  dislikes: z.array(ProfilePreferenceItemSchema),
+  allergies: z.array(ProfilePreferenceItemSchema)
+});
+var UpdateProfileRequestSchema = z.object({
+  username: z.string().min(1).max(50),
+  profileImageUrl: z.string().url().nullable(),
+  bio: z.string().max(500).nullable()
+});
+var OnboardingPreferenceRequestSchema = z.object({
+  likedCodes: z.array(z.string()),
+  dislikedCodes: z.array(z.string()),
+  allergyCodes: z.array(z.string())
+});
+var OnboardingRequestSchema = UpdateProfileRequestSchema.merge(
+  OnboardingPreferenceRequestSchema
+);
+var PreferenceMetaResponseSchema = z.object({
+  onboardedAt: ISODateTimeStringSchema.nullable(),
+  lastUpdatedAt: ISODateTimeStringSchema.nullable(),
+  revision: z.number().int().min(0)
+});
+
+export {
+  MemberRoleSchema,
+  MemberCoreSchema,
+  MemberResponseSchema,
+  MemberSummaryResponseSchema,
+  AuthPrincipalSchema,
+  ProfilePreferenceItemSchema,
+  ProfileDetailResponseSchema,
+  UpdateProfileRequestSchema,
+  OnboardingPreferenceRequestSchema,
+  OnboardingRequestSchema,
+  PreferenceMetaResponseSchema
+};

package/dist/chunk-NW5O4R7M.js

@@ -0,0 +1,37 @@
+import {
+  RestaurantIdSchema
+} from "./chunk-UFVPFUMI.js";
+
+// src/domain/restaurant/schema/restaurant.schema.ts
+import { z } from "zod";
+var RestaurantSchema = z.object({
+  restaurantId: RestaurantIdSchema,
+  placeName: z.string(),
+  categoryName: z.string(),
+  categoryGroupName: z.string(),
+  distance: z.string().optional(),
+  roadAddressName: z.string(),
+  addressName: z.string(),
+  phone: z.string().nullable(),
+  placeUrl: z.string().url().nullable(),
+  lat: z.number(),
+  lng: z.number()
+});
+var KakaoPlaceRawSchema = z.object({
+  id: RestaurantIdSchema,
+  place_name: z.string(),
+  category_name: z.string(),
+  category_group_name: z.string(),
+  distance: z.string(),
+  road_address_name: z.string(),
+  address_name: z.string(),
+  phone: z.string(),
+  place_url: z.string().url().optional(),
+  lat: z.number(),
+  lng: z.number()
+});
+
+export {
+  RestaurantSchema,
+  KakaoPlaceRawSchema
+};

package/dist/chunk-UFVPFUMI.js

@@ -0,0 +1,35 @@
+// src/domain/common/schema/id.schema.ts
+import { z } from "zod";
+var PositiveIntIdSchema = z.number().int().positive();
+var NonEmptyStringIdSchema = 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 = z.string().min(4).max(64).brand();
+
+export {
+  PositiveIntIdSchema,
+  NonEmptyStringIdSchema,
+  MemberIdSchema,
+  UserIdSchema,
+  ArticleIdSchema,
+  CommentIdSchema,
+  RecruitIdSchema,
+  PlanIdSchema,
+  InvitationIdSchema,
+  RoomIdSchema,
+  RestaurantIdSchema,
+  CouponIdSchema,
+  SubscriptionIdSchema,
+  FriendRequestIdSchema,
+  ReferralCodeSchema
+};

package/dist/chunk-UXA4FHST.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+export {
+  __export,
+  __decorateClass
+};

package/dist/chunk-YVACD5IG.js

@@ -0,0 +1,127 @@
+import {
+  RestaurantSchema
+} from "./chunk-NW5O4R7M.js";
+import {
+  MemberResponseSchema
+} from "./chunk-MP7TEKEI.js";
+import {
+  ArticleIdSchema,
+  CommentIdSchema,
+  MemberIdSchema
+} from "./chunk-UFVPFUMI.js";
+import {
+  ISODateStringSchema,
+  ISODateTimeStringSchema
+} from "./chunk-HRM3FQPL.js";
+
+// src/domain/common/schema/pagination.schema.ts
+import { z } from "zod";
+var PageRequestSchema = z.object({
+  page: z.number().int().min(0).default(0),
+  size: z.number().int().min(1).max(100).default(20)
+});
+var SortObjectSchema = z.object({
+  empty: z.boolean(),
+  sorted: z.boolean(),
+  unsorted: z.boolean()
+});
+var PageableObjectSchema = z.object({
+  offset: z.number().int().min(0),
+  sort: SortObjectSchema,
+  paged: z.boolean(),
+  pageNumber: z.number().int().min(0),
+  pageSize: z.number().int().min(1),
+  unpaged: z.boolean()
+});
+var PageResponseSchema = (item) => z.object({
+  totalElements: z.number().int().min(0),
+  totalPages: z.number().int().min(0),
+  first: z.boolean(),
+  size: z.number().int().min(0),
+  content: z.array(item),
+  number: z.number().int().min(0),
+  sort: SortObjectSchema,
+  numberOfElements: z.number().int().min(0),
+  pageable: PageableObjectSchema,
+  last: z.boolean(),
+  empty: z.boolean()
+});
+
+// src/domain/article/schema/article.schema.ts
+import { z as z2 } from "zod";
+var FoodAnalysisResultSchema = z2.object({
+  code: z2.string(),
+  label: z2.string(),
+  confidence: z2.number().min(0).max(1),
+  tsUtc: ISODateTimeStringSchema.optional()
+});
+var ArticlePostRequestSchema = z2.object({
+  imageUrl: z2.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  taggedMemberIds: z2.array(MemberIdSchema).default([]),
+  foodAnalysis: FoodAnalysisResultSchema.optional()
+});
+var CreateArticleResponseSchema = z2.object({
+  articleId: ArticleIdSchema
+});
+var CommentPostRequestSchema = z2.object({
+  content: z2.string().min(1).max(500),
+  parentCommentId: CommentIdSchema.nullish()
+});
+var CreateCommentResponseSchema = z2.object({
+  commentId: CommentIdSchema
+});
+var CommentResponseSchema = z2.object({
+  commentId: CommentIdSchema,
+  author: MemberResponseSchema,
+  parentCommentId: CommentIdSchema.nullable(),
+  content: z2.string(),
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema
+});
+var ArticleCoreSchema = z2.object({
+  articleId: ArticleIdSchema,
+  author: MemberResponseSchema,
+  imageUrl: z2.string().url(),
+  mealDate: ISODateStringSchema,
+  restaurant: RestaurantSchema,
+  createdAt: ISODateTimeStringSchema,
+  updatedAt: ISODateTimeStringSchema,
+  expiresAt: ISODateTimeStringSchema,
+  taggedMembers: z2.array(MemberResponseSchema)
+});
+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(CommentResponseSchema).optional()
+});
+var PageArticleSummaryResponseSchema = PageResponseSchema(
+  ArticleSummaryResponseSchema
+);
+var PresignUploadResponseSchema = z2.object({
+  key: z2.string(),
+  putUrl: z2.string().url(),
+  cdnUrl: z2.string().url()
+});
+
+export {
+  PageRequestSchema,
+  SortObjectSchema,
+  PageableObjectSchema,
+  PageResponseSchema,
+  FoodAnalysisResultSchema,
+  ArticlePostRequestSchema,
+  CreateArticleResponseSchema,
+  CommentPostRequestSchema,
+  CreateCommentResponseSchema,
+  CommentResponseSchema,
+  ArticleCoreSchema,
+  ArticleSummaryResponseSchema,
+  ArticleDetailResponseSchema,
+  PageArticleSummaryResponseSchema,
+  PresignUploadResponseSchema
+};

package/dist/chunk-Z2UFF3MA.js

@@ -0,0 +1,212 @@
+import {
+  AcceptInvitationResponseSchema,
+  ApiResponseSchema,
+  ApiSuccessSchema,
+  InvitationListItemResponseSchema,
+  InvitationPostRequestSchema,
+  NoContentSchema,
+  RejectInvitationResponseSchema,
+  SendInvitationResponseSchema
+} from "./chunk-4DAOP35P.js";
+import {
+  MealStatusResponseSchema,
+  UpdateMealStatusRequestSchema
+} from "./chunk-7MGHUZXI.js";
+import {
+  CreatePlanRequestSchema,
+  PlanResponseSchema
+} from "./chunk-ZNAAA53X.js";
+import {
+  FoodPreferenceResponseSchema
+} from "./chunk-F24BT6H4.js";
+import {
+  CreateRecruitResponseSchema,
+  RecruitRequestSchema,
+  RecruitResponseSchema
+} from "./chunk-2SJCUQNN.js";
+import {
+  RedeemReferralRequestSchema,
+  ReferralCreateResponseSchema,
+  ReferralItemResponseSchema
+} from "./chunk-ZSZ3ETY7.js";
+import {
+  ArticleDetailResponseSchema,
+  ArticlePostRequestSchema,
+  CommentPostRequestSchema,
+  CreateArticleResponseSchema,
+  CreateCommentResponseSchema,
+  PageArticleSummaryResponseSchema,
+  PresignUploadResponseSchema
+} from "./chunk-YVACD5IG.js";
+import {
+  LoginRequestSchema,
+  SignupRequestSchema,
+  SignupResponseSchema,
+  TokenResponseSchema
+} from "./chunk-FCE6KXNO.js";
+import {
+  ChallengeStatusResponseSchema,
+  ClaimChallengeRewardRequestSchema,
+  ClaimChallengeRewardResponseSchema
+} from "./chunk-6NZPEF4K.js";
+import {
+  FriendActionRequestSchema,
+  FriendBlockItemResponseSchema,
+  FriendListItemResponseSchema,
+  FriendMealFilterSchema,
+  FriendMealItemResponseSchema,
+  FriendRequestItemResponseSchema
+} from "./chunk-JCN37ARR.js";
+import {
+  MemberResponseSchema,
+  MemberSummaryResponseSchema,
+  OnboardingPreferenceRequestSchema,
+  OnboardingRequestSchema,
+  PreferenceMetaResponseSchema,
+  ProfileDetailResponseSchema,
+  UpdateProfileRequestSchema
+} from "./chunk-MP7TEKEI.js";
+import {
+  CouponResponseSchema
+} from "./chunk-IJMADVK5.js";
+import {
+  ArticleIdSchema,
+  CommentIdSchema,
+  CouponIdSchema,
+  FriendRequestIdSchema,
+  InvitationIdSchema,
+  MemberIdSchema,
+  PlanIdSchema,
+  RecruitIdSchema,
+  RestaurantIdSchema,
+  RoomIdSchema
+} from "./chunk-UFVPFUMI.js";
+
+// 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 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 })
+  },
+  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 })
+  },
+  articles: {
+    list: endpoint({ method: "GET", path: "/articles", response: PageArticleSummaryResponseSchema }),
+    detail: endpoint({ method: "GET", path: "/articles/:articleId", pathParams: articleIdParam, response: ArticleDetailResponseSchema }),
+    create: endpoint({ method: "POST", path: "/articles", body: ArticlePostRequestSchema, response: CreateArticleResponseSchema }),
+    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 })
+  },
+  recruits: {
+    list: endpoint({ method: "GET", path: "/recruits", response: z2.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 })
+  },
+  invitations: {
+    list: endpoint({ method: "GET", path: "/invitations", response: z2.array(InvitationListItemResponseSchema) }),
+    send: endpoint({ method: "POST", path: "/invitations", body: InvitationPostRequestSchema, 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 })
+  },
+  plans: {
+    list: endpoint({ method: "GET", path: "/plans", response: z2.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 })
+  },
+  friends: {
+    list: endpoint({ method: "GET", path: "/friends", response: z2.array(FriendListItemResponseSchema) }),
+    meals: endpoint({ method: "GET", path: "/friends/meals", query: z2.object({ filter: FriendMealFilterSchema.optional() }), response: z2.array(FriendMealItemResponseSchema) }),
+    blocks: endpoint({ method: "GET", path: "/friends/blocks", response: z2.array(FriendBlockItemResponseSchema) }),
+    request: endpoint({ method: "POST", path: "/friends/requests", body: FriendActionRequestSchema, response: FriendRequestItemResponseSchema }),
+    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: z2.array(FoodPreferenceResponseSchema) })
+  },
+  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: ClaimChallengeRewardResponseSchema })
+  },
+  referrals: {
+    create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
+    list: endpoint({ method: "GET", path: "/referrals", response: z2.array(ReferralItemResponseSchema) }),
+    redeem: endpoint({ method: "POST", path: "/referrals/redeem", body: RedeemReferralRequestSchema, response: NoContentSchema })
+  }
+};
+
+// 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);
+
+export {
+  NoBodySchema,
+  NoQuerySchema,
+  NoParamsSchema,
+  endpoint,
+  apiContract,
+  makeApiResponseSchema,
+  makeApiSuccessSchema,
+  toMemberId,
+  toArticleId,
+  toRecruitId,
+  toInvitationId,
+  toRoomId,
+  toRestaurantId
+};